From 03ecd24d94e77991cf1c0613812e7bd08168aedb Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 15 Oct 2026 10:54:40 +0200
Subject: [PATCH 1/6] feat(verify): prepare package-backed provider declaration
 loader

---
 Directory.Packages.local.props                |   3 +
 ...ernance-423-neutral-capability-bindings.md |  26 ++
 .../FS.GG.Governance.VerifyCommand.fsproj     |   4 +
 .../Interpreter.fs                            |   6 +
 .../Interpreter.fsi                           |   4 +
 src/FS.GG.Governance.VerifyCommand/Loop.fsi   |   2 +-
 src/FS.GG.Governance.VerifyCommand/Program.fs |  70 ++++-
 .../ProviderContextLoader.fs                  |  87 ++++++
 .../ProviderContextLoader.fsi                 |  14 +
 ...FS.GG.Governance.VerifyCommand.surface.txt |   1 +
 ...S.GG.Governance.VerifyCommand.Tests.fsproj |   2 +
 .../ProviderContextLoaderTests.fs             | 127 +++++++++
 .../ProviderLoaderFixture.fs                  | 251 ++++++++++++++++++
 13 files changed, 584 insertions(+), 13 deletions(-)
 create mode 100644 src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fs
 create mode 100644 src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fsi
 create mode 100644 tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
 create mode 100644 tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs

diff --git a/Directory.Packages.local.props b/Directory.Packages.local.props
index ec27ded9..c237bbf4 100644
--- a/Directory.Packages.local.props
+++ b/Directory.Packages.local.props
@@ -36,6 +36,9 @@
        (see nuget.config). Contract id: fsgg-contracts (registry/dependencies.yml). -->
   <ItemGroup>
     <PackageVersion Include="FS.GG.Contracts" Version="7.6.0" />
+    <!-- Local retained candidate only; package qualification and public availability remain separate. -->
+    <PackageVersion Include="FS.GG.SDD.Commands" Version="2.3.0" />
+    <PackageVersion Include="FS.GG.SDD.Artifacts" Version="2.3.0" />
   </ItemGroup>
 
   <!-- Runtime: rich terminal rendering + a minimal read-only TUI for the F27 human projections.
diff --git a/docs/roadmaps/governance-423-neutral-capability-bindings.md b/docs/roadmaps/governance-423-neutral-capability-bindings.md
index 7b87f8c9..cc0e561f 100644
--- a/docs/roadmaps/governance-423-neutral-capability-bindings.md
+++ b/docs/roadmaps/governance-423-neutral-capability-bindings.md
@@ -359,3 +359,29 @@ pending and retain the original caller owner and failure evidence. The existing
 Program/Verify integration, stronger profiles, coherent SDD consumer joins and C3/C4 milestones remain
 open. The owning Atlas archive records `governance/provider-capture-retention-boundary`; retrieve it
 with the Atlas helper and verify its immutable source citations before reuse.
+
+
+### GOV423-C2 phase-2 package loader preparation (2026-10-15)
+
+Source preparation targets the retained SDD Commands/Artifacts 2.3.0 candidate from
+run `37951954780`, artifact `11626413573`, source
+`c8aea9289a6cc410f076823bf1219a02314f00a7`. Selection is not package qualification
+or public availability. The package-backed adapter decodes immutable observations from the
+original Ready capture session, strictly parses schema-2 provenance and independently selected
+policy, binds policy/platform/admission correspondence, and recomputes the whole Config request
+before catalog selection, cache or execution. Literal argv stays typed throughout.
+
+The provider interpreter drives the existing non-passing Verify planning transition. Program
+parses all explicit provider selectors and supplies a caller-owned-session adapter; it never
+acquires or releases that session. Standalone `main` explicitly returns input-unavailable for
+provider mode because an independently admitted outer capture lifetime and teardown owner are
+not yet supplied. This is an unresolved production-entry prerequisite, not usable provider-mode
+availability. Legacy invocations retain the existing interpreter path.
+
+Focused source controls cover actual package codecs, raw digests, strict UTF-8/schema refusal,
+independent policy/platform correspondence and the Program-to-planning join. Fixtures are
+synthetic declarations and observations, not execution evidence. Local CLR, restore/lock
+regeneration, compilation and test execution were held under the programme resource limit;
+these controls remain unverified. Package-only qualification, exact-head hosted validation,
+physical capture acceptance, production owner integration, source/evidence revalidation and
+the real SDD-to-Verify/GateExecution journey remain open. C2 remains unchecked.
diff --git a/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj b/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
index 5a8fa99f..f46c2d64 100644
--- a/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
+++ b/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
@@ -50,6 +50,8 @@
     <Compile Include="ProviderContext.fs" />
     <Compile Include="ProviderContextCapture.fsi" />
     <Compile Include="ProviderContextCapture.fs" />
+    <Compile Include="ProviderContextLoader.fsi" />
+    <Compile Include="ProviderContextLoader.fs" />
     <Compile Include="Loop.fsi" />
     <Compile Include="Loop.fs" />
     <Compile Include="Interpreter.fsi" />
@@ -59,6 +61,8 @@
 
   <ItemGroup>
     <PackageReference Include="FSharp.Core" />
+    <PackageReference Include="FS.GG.SDD.Commands" />
+    <PackageReference Include="FS.GG.SDD.Artifacts" />
   </ItemGroup>
 
   <!--
diff --git a/src/FS.GG.Governance.VerifyCommand/Interpreter.fs b/src/FS.GG.Governance.VerifyCommand/Interpreter.fs
index a11f7ecc..11dd29b3 100644
--- a/src/FS.GG.Governance.VerifyCommand/Interpreter.fs
+++ b/src/FS.GG.Governance.VerifyCommand/Interpreter.fs
@@ -497,3 +497,9 @@ module Interpreter =
         // Drive init → update* to Done: execute every requested Effect via `step`, feed each result Msg back
         // into the pure `update`, accumulate new effects, repeat. Stops at Done or quiescence. NEVER throws.
         CommandHost.drive (fun (m: Loop.Model) -> m.Phase = Loop.Done) (step ports) Loop.update m0 eff0
+
+    let runProviderPlanning (ports: Ports) (request: Loop.RunRequest) (provider: Loop.ProviderPlanningInput) : Loop.ProviderModel =
+        let model, effects = Loop.initProviderPlanning request provider
+        CommandHost.drive
+            (fun (m: Loop.ProviderModel) -> m.Legacy.Phase = Loop.Done)
+            (step ports) Loop.updateProviderPlanning model effects
diff --git a/src/FS.GG.Governance.VerifyCommand/Interpreter.fsi b/src/FS.GG.Governance.VerifyCommand/Interpreter.fsi
index 0dedb8b2..83067279 100644
--- a/src/FS.GG.Governance.VerifyCommand/Interpreter.fsi
+++ b/src/FS.GG.Governance.VerifyCommand/Interpreter.fsi
@@ -107,3 +107,7 @@ module Interpreter =
     /// result `Msg` back into `Loop.update`, and stop at `Done`. Returns the terminal `Loop.Model` (carrying
     /// the decided `ExitDecision` — including a `Blocked` verdict). TOTAL — never throws.
     val run: ports: Ports -> request: Loop.RunRequest -> Loop.Model
+
+    /// Drive the actual provider planning transition with the existing effect interpreter.
+    /// Valid declarations remain non-passing; no provider execution or evidence acceptance is supplied.
+    val runProviderPlanning: ports: Ports -> request: Loop.RunRequest -> provider: Loop.ProviderPlanningInput -> Loop.ProviderModel
diff --git a/src/FS.GG.Governance.VerifyCommand/Loop.fsi b/src/FS.GG.Governance.VerifyCommand/Loop.fsi
index 4da80dd2..8b43cc03 100644
--- a/src/FS.GG.Governance.VerifyCommand/Loop.fsi
+++ b/src/FS.GG.Governance.VerifyCommand/Loop.fsi
@@ -302,7 +302,7 @@ module Loop =
     val parse: argv: string list -> Result<RunRequest, UsageError>
 
     /// Validate explicit provider options, then parse the original token stream with their boundaries
-    /// retained. This pure API creates no ports; Program remains on legacy parse until loader admission.
+    /// retained. This pure API creates no ports; Program routes provider requests without falling back to legacy execution.
     val parseInvocation: argv: string list -> Result<Invocation, InvocationError>
 
     /// Initial state plus the first requested effect(s) for a valid request (Principle IV `init`).
diff --git a/src/FS.GG.Governance.VerifyCommand/Program.fs b/src/FS.GG.Governance.VerifyCommand/Program.fs
index bbc02fce..4e06125d 100644
--- a/src/FS.GG.Governance.VerifyCommand/Program.fs
+++ b/src/FS.GG.Governance.VerifyCommand/Program.fs
@@ -1,6 +1,6 @@
 // The thin host entry for `fsgg verify` (F056): parse argv → build the real ports → run the interpreter →
 // print any diagnostics to stderr → return the mapped exit code. ALL decision logic lives in the pure
-// `Loop`; ALL I/O in the `Interpreter`. A `parse` rejection exits 2 BEFORE any port is built, so a usage
+// `Loop`; ALL I/O in the `Interpreter`. A parse rejection exits 2 BEFORE any port is built, so a usage
 // error (including an unrecognized profile or a forbidden `--mode`) writes no artifact and starts no
 // git/filesystem work. A blocked verdict is NOT a diagnostic — it is reported in the summary and surfaces as
 // exit 1. Verify is NOT the merge authority (FR-017): a passing `fsgg verify` does not authorize a merge.
@@ -26,17 +26,63 @@ let categoryToken (decision: Loop.ExitDecision) : string =
     | Loop.InputUnavailable -> "input-unavailable"
     | Loop.ToolError -> "tool-error"
 
-[<EntryPoint>]
-let main argv =
-    match Loop.parse (List.ofArray argv) with
-    | Error err ->
-        eprintfn "fsgg verify: %s" (usageMessage err)
+// The caller of this seam owns any original capture session for the whole invocation.
+// A loader rejection precedes real-port construction, catalog reads and legacy execution.
+let internal runWithProviderLoader
+    (loadProvider: Loop.RunRequest -> ProviderContext.Selection -> Result<Loop.ProviderPlanningInput, string>)
+    (makePorts: string -> Interpreter.Ports)
+    (report: string -> unit)
+    argv =
+    match Loop.parseInvocation (List.ofArray argv) with
+    | Error(Loop.LegacyUsage err) ->
+        report ("fsgg verify: " + usageMessage err)
+        Loop.exitCode Loop.UsageError'
+    | Error(Loop.ProviderUsage err) ->
+        report (sprintf "fsgg verify: provider selection rejected: %A" err)
         Loop.exitCode Loop.UsageError'
-    | Ok request ->
-        let ports = Interpreter.realPorts request.Repo
-        let model = Interpreter.run ports request
+    | Ok invocation ->
+        let outcome =
+            match invocation.Provider with
+            | None -> Ok(Interpreter.run (makePorts invocation.Request.Repo) invocation.Request)
+            | Some selection ->
+                match loadProvider invocation.Request selection with
+                | Error message -> Error message
+                | Ok provider ->
+                    let model = Interpreter.runProviderPlanning (makePorts invocation.Request.Repo) invocation.Request provider
+                    Ok model.Legacy
+        match outcome with
+        | Error message ->
+            report ("fsgg verify [input-unavailable]: " + message)
+            Loop.exitCode Loop.InputUnavailable
+        | Ok model ->
+            for diagnostic in model.Diagnostics do
+                report (sprintf "fsgg verify [%s]: %s" (categoryToken diagnostic.Category) diagnostic.Message)
+            Loop.exitCode model.Exit
 
-        for d in model.Diagnostics do
-            eprintfn "fsgg verify [%s]: %s" (categoryToken d.Category) d.Message
+// The supplying caller retains every returned session, including failures, through its own teardown.
+// This adapter performs no acquisition, renewal, release, disposal or provider execution.
+let internal runWithCapturedProvider
+    (supply: Loop.RunRequest -> ProviderContext.Selection -> Result<ProviderContextCapture.CaptureSession * FS.GG.Governance.GateRun.Plan.ProviderCommandContext, string>)
+    makePorts report argv =
+    let load request selection =
+        match supply request selection with
+        | Error message -> Error message
+        | Ok(session, context) ->
+            let observation = ProviderContextCapture.inspect session
+            let root = System.IO.Path.GetFullPath request.Repo
+            if context.RepoRoot <> root
+               || not (observation.Roots |> List.exists (fun r -> r.RequestedPath = root && r.CurrentBindingMatches = Some true)) then
+                Error "provider command context does not bind the original captured repository root"
+            else
+                match ProviderContextLoader.load selection session with
+                | Error errors -> Error(sprintf "provider declaration admission rejected: %A" errors)
+                | Ok resolution -> Ok ({ ResolutionRequest = resolution; CommandContext = context }: Loop.ProviderPlanningInput)
+    runWithProviderLoader load makePorts report argv
 
-        Loop.exitCode model.Exit
+[<EntryPoint>]
+let main argv =
+    // Standalone capture cannot yet establish its externally owned lifetime/teardown contract.
+    // Preserve that exact missing prerequisite instead of starting an unowned native activity.
+    let unavailable _ _ =
+        Error "provider capture requires an independently admitted caller-owned lifetime and teardown boundary; standalone provider execution is unavailable"
+    runWithProviderLoader unavailable Interpreter.realPorts (eprintfn "%s") argv
diff --git a/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fs b/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fs
new file mode 100644
index 00000000..92a8da97
--- /dev/null
+++ b/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fs
@@ -0,0 +1,87 @@
+namespace FS.GG.Governance.VerifyCommand
+
+open System
+open System.Security.Cryptography
+open System.Text
+open FS.GG.SDD.Commands
+open FS.GG.SDD.Artifacts
+
+module internal ProviderContextLoader =
+    module CB = FS.GG.Governance.Config.CapabilityBindings
+    module Capture = ProviderContextCapture
+
+    let diagnostic path message : Fsgg.ProviderCatalog.Diagnostic =
+        { Code = "verify.providerContextInvalid"; Path = path; Message = message }
+
+    let refused path message = Error [ diagnostic path message ]
+    let digest (bytes: byte array) = Convert.ToHexString(SHA256.HashData bytes).ToLowerInvariant()
+    let sameDigest a b = String.Equals(a, b, StringComparison.OrdinalIgnoreCase)
+
+    let decode (selection: ProviderContext.Selection) (provenanceBytes: byte array) (policyBytes: byte array) =
+        try
+            if not (sameDigest (digest provenanceBytes) selection.ProvenanceSha256) then
+                refused "$.provenance" "Selected raw provenance digest does not match captured bytes."
+            elif not (sameDigest (digest policyBytes) selection.PolicySha256) then
+                refused "$.policy" "Selected raw policy digest does not match captured bytes."
+            else
+                match CatalogScaffoldPolicy.parse ("sha256:" + digest policyBytes) policyBytes with
+                | Error errors -> Error errors
+                | Ok policy ->
+                    let text = UTF8Encoding(false, true).GetString provenanceBytes
+                    match ScaffoldProvenanceDocument.parse text with
+                    | Error errors -> Error errors
+                    | Ok(ScaffoldProvenanceDocument.Legacy _) ->
+                        refused "$.provenance.schemaVersion" "Explicit provider mode requires schema-2 catalog provenance."
+                    | Ok(ScaffoldProvenanceDocument.Catalog provenance) ->
+                        let declaration = provenance.Declaration
+                        let admission = declaration.Admission
+                        let identityMatches (recorded: CatalogScaffoldProvenance.Identity) (selected: CatalogScaffoldPolicy.Identity) =
+                            recorded.Id = selected.Id && recorded.Version = selected.Version && recorded.Digest = selected.Digest
+                        let selectedFormats = policy.SupportedEvidenceFormats |> List.map (fun f -> f.Id, f.Version) |> List.sort
+                        let recordedFormats = admission.SupportedFormats |> List.map (fun f -> f.Id, f.Version) |> List.sort
+                        let selectedMappings = policy.EvidenceMappings |> List.map (fun m -> m.Format, m.Id, m.Version) |> List.sort
+                        let recordedMappings = admission.EvidenceMappings |> List.map (fun m -> m.Format, m.Id, m.Version) |> List.sort
+                        let policyMatches =
+                            identityMatches declaration.Policy policy.Identity
+                            && identityMatches declaration.EvidenceMap policy.EvidenceMapIdentity
+                            && List.sort admission.RequiredCapabilityIds = List.sort policy.RequiredCapabilityIds
+                            && List.sort admission.SemanticOnlyCapabilityIds = List.sort policy.SemanticOnlyCapabilityIds
+                            && List.sort admission.SupportedPlatforms = List.sort policy.KnownPlatforms
+                            && List.sort admission.SupportedEnvironmentIds = (policy.EnvironmentBindings |> List.map (fun e -> e.Id) |> List.sort)
+                            && recordedFormats = selectedFormats && recordedMappings = selectedMappings
+                        if admission.Platform <> selection.Platform || provenance.Observation.Platform <> selection.Platform then
+                            refused "$.platform" "Selected platform differs from provenance declaration or observation."
+                        elif declaration.Budgets.AdmittedPreflightSeconds > policy.MaximumPreflightSeconds
+                             || declaration.Budgets.AdmittedScaffoldSeconds > policy.MaximumScaffoldSeconds then
+                            refused "$.policy.budgets" "Recorded admission exceeds the independently selected policy ceilings."
+                        elif not policyMatches then
+                            refused "$.policy" "Provenance admission differs from the independently selected policy."
+                        else
+                            match ProviderCapabilityAdmission.request policy selection.Platform declaration.Descriptor with
+                            | Error errors -> Error errors
+                            | Ok request ->
+                                // Whole-request refusal precedes catalog selection, cache reads and empty selection.
+                                match CB.resolve request with
+                                | CB.Rejected errors ->
+                                    errors |> List.map (fun d -> diagnostic ("$.bindings." + d.CapabilityId + "." + d.Field) d.Message) |> Error
+                                | CB.Resolved _ -> Ok request
+        with
+        | :? DecoderFallbackException -> refused "$.provenance" "Captured provenance is not strict UTF-8."
+
+    let load (selection: ProviderContext.Selection) (session: Capture.CaptureSession) =
+        let observation = Capture.inspect session
+        if observation.Model.Phase <> Capture.Ready || not observation.Model.CaptureConsumed
+           || observation.Model.FirstFailure.IsSome || not (List.isEmpty observation.Model.SecondaryFailures)
+           || observation.Settlement <> Capture.Retained || observation.WorkEndReached
+           || observation.CleanupEndReached || observation.CancellationObserved
+           || List.isEmpty observation.Roots || (observation.Roots |> List.exists (fun r -> r.CurrentBindingMatches <> Some true)) then
+            refused "$.capture" "Original capture is not ready for declaration admission; its caller retains ownership."
+        else
+            let selected role path expected =
+                observation.Documents
+                |> List.filter (fun d -> d.Role = role && d.SelectedPath = path && sameDigest d.RawSha256 expected && d.ComparisonPasses > 0)
+            match selected "provenance" selection.ProvenancePath selection.ProvenanceSha256,
+                  selected "policy" selection.PolicyPath selection.PolicySha256 with
+            | [ provenance ], [ policy ] when observation.Documents.Length = 2 ->
+                decode selection (provenance.Bytes |> Seq.toArray) (policy.Bytes |> Seq.toArray)
+            | _ -> refused "$.capture.documents" "Exactly the selected, compared provenance and policy documents are required."
diff --git a/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fsi b/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fsi
new file mode 100644
index 00000000..0839df9f
--- /dev/null
+++ b/src/FS.GG.Governance.VerifyCommand/ProviderContextLoader.fsi
@@ -0,0 +1,14 @@
+namespace FS.GG.Governance.VerifyCommand
+
+/// Package-backed declaration admission. The original capture owner remains with the caller.
+module internal ProviderContextLoader =
+    /// Strict byte decoding and independent policy binding; no recorded resolved set is trusted.
+    val decode:
+        ProviderContext.Selection -> byte array -> byte array ->
+            Result<FS.GG.Governance.Config.CapabilityBindings.ResolutionRequest, Fsgg.ProviderCatalog.Diagnostic list>
+
+    /// Read immutable observations from the original ready session; never acquire or release it.
+    /// This establishes declaration identity only, not current source or execution acceptance.
+    val load:
+        ProviderContext.Selection -> ProviderContextCapture.CaptureSession ->
+            Result<FS.GG.Governance.Config.CapabilityBindings.ResolutionRequest, Fsgg.ProviderCatalog.Diagnostic list>
diff --git a/surface/FS.GG.Governance.VerifyCommand.surface.txt b/surface/FS.GG.Governance.VerifyCommand.surface.txt
index fcfe4580..19f28869 100644
--- a/surface/FS.GG.Governance.VerifyCommand.surface.txt
+++ b/surface/FS.GG.Governance.VerifyCommand.surface.txt
@@ -2,6 +2,7 @@ TYPE FS.GG.Governance.VerifyCommand.InterpreterModule
   [Method] Model run(Ports, RunRequest)
   [Method] Msg step(Ports, Effect)
   [Method] Ports realPorts(System.String)
+  [Method] ProviderModel runProviderPlanning(Ports, RunRequest, ProviderPlanningInput)
   [NestedType] FS.GG.Governance.VerifyCommand.InterpreterModule+Ports
 TYPE FS.GG.Governance.VerifyCommand.InterpreterModule+Ports
   [Constructor] Void .ctor(Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpResult`2[Microsoft.FSharp.Core.FSharpOption`1[System.String],System.String]], FS.GG.Governance.Snapshot.Ports, FreshnessSensor, Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpResult`2[Microsoft.FSharp.Core.FSharpOption`1[FS.GG.Governance.EvidenceReuse.ModelModule+ReuseStore],System.String]], Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.FSharpResult`2[Microsoft.FSharp.Core.Unit,System.String]]], Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[FS.GG.Governance.GateExecution.ModelModule+GateCommand,FS.GG.Governance.GateExecution.ModelModule+ExecutionOutcome], Microsoft.FSharp.Core.FSharpFunc`2[System.Boolean,FS.GG.Governance.HumanText.RenderModeModule+ColorCapability], Microsoft.FSharp.Core.FSharpFunc`2[FS.GG.Governance.HumanText.ReportViewModule+ReportView,Microsoft.FSharp.Core.Unit], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FS.GG.Governance.Config.ModelModule+EnvironmentClass], Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.Unit,FS.GG.Governance.Provenance.ModelModule+BuilderIdentity], Microsoft.FSharp.Core.FSharpFunc`2[FS.GG.Governance.ReleaseFactsSensing.ModelModule+SourceLayout,Microsoft.FSharp.Core.FSharpFunc`2[FS.GG.Governance.ReleaseFactsSensing.ModelModule+ReleaseExpectations,FS.GG.Governance.ReleaseFactsSensing.ModelModule+SensedRelease]], Microsoft.FSharp.Core.FSharpFunc`2[FS.GG.Governance.ProductSurfaces.ModelModule+ProductSurfaceReport,Microsoft.FSharp.Collections.FSharpList`1[FS.GG.Governance.SurfaceChecks.ModelModule+SurfaceFinding]], Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[FS.GG.Governance.CurrencyEnforcement.CurrencyEnforcementModule+CurrencyFinding]], Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Collections.FSharpList`1[FS.GG.Governance.Adapters.SddHandoff.ReaderModule+HandoffRead]])
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/FS.GG.Governance.VerifyCommand.Tests.fsproj b/tests/FS.GG.Governance.VerifyCommand.Tests/FS.GG.Governance.VerifyCommand.Tests.fsproj
index 5afc3d68..db6e176a 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/FS.GG.Governance.VerifyCommand.Tests.fsproj
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/FS.GG.Governance.VerifyCommand.Tests.fsproj
@@ -21,6 +21,8 @@
     <Compile Include="ParseTests.fs" />
     <Compile Include="LoopTests.fs" />
     <Compile Include="ProviderPlanningTests.fs" />
+    <Compile Include="ProviderLoaderFixture.fs" />
+    <Compile Include="ProviderContextLoaderTests.fs" />
     <Compile Include="EndToEndTests.fs" />
     <Compile Include="CurrencyTests.fs" />
     <Compile Include="ReuseTests.fs" />
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
new file mode 100644
index 00000000..68a5d58d
--- /dev/null
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
@@ -0,0 +1,127 @@
+module FS.GG.Governance.VerifyCommand.Tests.ProviderContextLoaderTests
+
+open System
+open System.Text
+open System.Security.Cryptography
+open Expecto
+open FS.GG.Governance.VerifyCommand
+
+// Synthetic document bytes test actual selected package codecs; no capture or provider ran.
+let bytes (text: string) = Encoding.UTF8.GetBytes text
+let sha (value: byte array) = Convert.ToHexString(SHA256.HashData value).ToLowerInvariant()
+let policyBytes =
+    let mapping = "[]"
+    bytes ("""{"schemaVersion":1,"id":"fixture-policy","version":"1.0.0",
+      "evidenceMap":{"id":"fixture-map","version":"1.0.0","digest":"sha256:DIGEST","mappings":[]},
+      "requiredCapabilityIds":[],"semanticOnlyCapabilityIds":[],"knownPlatforms":["linux"],
+      "environments":[{"id":"fixture-local","environment":"local"}],"supportedEvidenceFormats":[],
+      "maximumPreflightSeconds":5,"maximumScaffoldSeconds":10,"toolProbes":[],"archives":[]}""".Replace("DIGEST", sha (bytes mapping)))
+let coherentPolicyBytes = bytes """{"schemaVersion":1,"id":"independent-qualification-policy","version":"1.0.0","evidenceMap":{"id":"qualification-map","version":"1.0.0","digest":"sha256:61dc9d0938fc1c23541de3941279db5f410e05620390c099d3bba3600f96efb8","mappings":[{"format":"opaque@literal","id":"opaque-format","version":"1.0.0"}]},"requiredCapabilityIds":["build:build"],"semanticOnlyCapabilityIds":[],"knownPlatforms":["fixture-platform"],"environments":[{"id":"fixture-local","environment":"local"}],"supportedEvidenceFormats":[{"id":"opaque-format","version":"1.0.0"}],"maximumPreflightSeconds":30,"maximumScaffoldSeconds":60,"toolProbes":[],"archives":[]}
+"""
+let coherentRecord () =
+    let policy =
+        match FS.GG.SDD.Commands.CatalogScaffoldPolicy.parse ("sha256:" + sha coherentPolicyBytes) coherentPolicyBytes with
+        | Ok value -> value
+        | Error errors -> failtestf "%A" errors
+    let original = ProviderLoaderFixture.synthetic ()
+    { original with Declaration =
+        { original.Declaration with
+            Policy = { Id = policy.Identity.Id; Version = policy.Identity.Version; Digest = policy.Identity.Digest }
+            EvidenceMap = { Id = policy.EvidenceMapIdentity.Id; Version = policy.EvidenceMapIdentity.Version; Digest = policy.EvidenceMapIdentity.Digest }
+            Admission = { original.Declaration.Admission with RequiredCapabilityIds = policy.RequiredCapabilityIds } } }
+let provenanceBytes record =
+    match FS.GG.SDD.Artifacts.CatalogScaffoldProvenance.serialize record with
+    | Ok text -> bytes text
+    | Error errors -> failtestf "%A" errors
+let selection provenance policy : ProviderContext.Selection =
+    { ProvenancePath = "readiness/provenance.json"; ProvenanceSha256 = sha provenance
+      PolicyPath = "/independent/policy.json"; PolicySha256 = sha policy; Platform = "linux" }
+let refusedAt path result =
+    match result with
+    | Ok _ -> failtest "Malformed input must not produce a request"
+    | Error errors -> Expect.isTrue (errors |> List.exists (fun (d: Fsgg.ProviderCatalog.Diagnostic) -> d.Path = path)) "located refusal"
+let argv =
+    [| "--provider-provenance"; "readiness/provenance.json"; "--provider-provenance-sha256"; String('a', 64)
+       "--provider-policy"; "/independent/policy.json"; "--provider-policy-sha256"; String('b', 64)
+       "--provider-platform"; "linux" |]
+
+[<Tests>]
+let tests = testList "ProviderContextLoader" [
+    testCase "coherent synthetic bytes use actual codecs and preserve complete literal request" (fun _ ->
+        let provenance = provenanceBytes (coherentRecord ())
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        match ProviderContextLoader.decode selected provenance coherentPolicyBytes with
+        | Error errors -> failtestf "%A" errors
+        | Ok request ->
+            Expect.equal request.RequiredCapabilityIds [ "build:build" ] "independent required floor"
+            match request.Bindings.Head.Binding with
+            | FS.GG.Governance.Config.CapabilityBindings.Command command ->
+                Expect.equal command.Arguments ProviderLoaderFixture.command.Arguments "literal argv"
+            | _ -> failtest "executable declaration lost")
+    testCase "independent policy cannot silently replace recorded required obligations" (fun _ ->
+        let record = coherentRecord ()
+        let provenance = provenanceBytes { record with Declaration = { record.Declaration with Admission = { record.Declaration.Admission with RequiredCapabilityIds = [] } } }
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        ProviderContextLoader.decode selected provenance coherentPolicyBytes |> refusedAt "$.policy")
+    testCase "coherent provenance cannot replace explicit selected platform" (fun _ ->
+        let provenance = provenanceBytes (coherentRecord ())
+        ProviderContextLoader.decode (selection provenance coherentPolicyBytes) provenance coherentPolicyBytes |> refusedAt "$.platform")
+
+    testCase "raw provenance mismatch refuses before package parsing" (fun _ ->
+        let original = bytes "{}"
+        ProviderContextLoader.decode (selection original policyBytes) (bytes "different") policyBytes |> refusedAt "$.provenance")
+    testCase "raw policy mismatch refuses before package parsing" (fun _ ->
+        let provenance = bytes "{}"
+        ProviderContextLoader.decode (selection provenance policyBytes) provenance (bytes "different") |> refusedAt "$.policy")
+    testCase "actual selected policy codec accepts prefixed recomputed raw digest" (fun _ ->
+        match FS.GG.SDD.Commands.CatalogScaffoldPolicy.parse ("sha256:" + sha policyBytes) policyBytes with
+        | Ok _ -> ()
+        | Error errors -> failtestf "%A" errors)
+    testCase "strict UTF8 refuses with valid independent policy" (fun _ ->
+        let provenance = [| 0xffuy |]
+        ProviderContextLoader.decode (selection provenance policyBytes) provenance policyBytes |> refusedAt "$.provenance")
+    testCase "unsupported provenance schema never becomes absence or legacy mode" (fun _ ->
+        let provenance = bytes "{\"schemaVersion\":99}"
+        match ProviderContextLoader.decode (selection provenance policyBytes) provenance policyBytes with
+        | Error errors -> Expect.isNonEmpty errors "actual package refusal"
+        | Ok _ -> failtest "Unsupported schema accepted")
+    testCase "Program provider path decodes actual bytes and drives nonpassing planning without legacy execution" (fun _ ->
+        let provenance = provenanceBytes (coherentRecord ())
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        let cap = Support.newCapture ()
+        let mutable loads = 0
+        let mutable execution = false
+        let mutable cache = false
+        let ports = Support.fakePorts Support.validCatalog Support.gitSrcChange cap
+        let ports = { ports with
+                        Execute = (fun _ -> execution <- true; failtest "provider planning cannot execute")
+                        Store = (fun _ -> cache <- true; failtest "provider planning cannot reuse") }
+        let load _ actual =
+            loads <- loads + 1
+            Expect.equal actual selected "all selectors routed unchanged"
+            match ProviderContextLoader.decode actual provenance coherentPolicyBytes with
+            | Error errors -> Error(sprintf "%A" errors)
+            | Ok request -> Ok ({ ResolutionRequest = request; CommandContext = ProviderPlanningTests.context }: Loop.ProviderPlanningInput)
+        let actualArgv =
+            [| "--provider-provenance"; selected.ProvenancePath; "--provider-provenance-sha256"; selected.ProvenanceSha256
+               "--provider-policy"; selected.PolicyPath; "--provider-policy-sha256"; selected.PolicySha256
+               "--provider-platform"; selected.Platform; "--paths"; "src/a.fs" |]
+        let code = Program.runWithProviderLoader load (fun _ -> ports) ignore actualArgv
+        Expect.equal loads 1 "single package-backed admission"
+        Expect.isTrue (code = 1 || code = 3) "planning refuses or remains blocked, never passes"
+        Expect.isFalse execution "no execution"
+        Expect.isFalse cache "no legacy reuse"
+        Expect.isEmpty cap.Writes "no passing artifact")
+    testCase "Program standalone provider path refuses without constructing real ports" (fun _ ->
+        let mutable created = false
+        let messages = ResizeArray<string>()
+        let code = Program.runWithProviderLoader (fun _ _ -> Error "original capture owner unavailable")
+                       (fun _ -> created <- true; failtest "ports must remain unbuilt") messages.Add argv
+        Expect.equal code 3 "input unavailable"
+        Expect.isFalse created "no ports"
+        Expect.isTrue (messages |> Seq.exists (fun m -> m.Contains "original capture owner")) "exact gap retained")
+    testCase "Program invalid provider usage never calls loader or ports" (fun _ ->
+        let code = Program.runWithProviderLoader (fun _ _ -> failtest "loader must remain uncalled")
+                       (fun _ -> failtest "ports must remain unbuilt") ignore [| "--provider-platform"; "linux" |]
+        Expect.equal code 2 "provider usage")
+]
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
new file mode 100644
index 00000000..25d25f2d
--- /dev/null
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
@@ -0,0 +1,251 @@
+namespace FS.GG.Governance.VerifyCommand.Tests
+
+// Synthetic codec/admission controls against retained package APIs; no provider execution.
+open System
+open System.Text
+open Fsgg
+open Fsgg.ProviderCatalog
+open FS.GG.SDD.Commands
+open FS.GG.SDD.Artifacts
+open FS.GG.SDD.Artifacts.ArtifactRef
+open FS.GG.SDD.Artifacts.ScaffoldProvenance
+open FS.GG.SDD.Artifacts.CatalogScaffoldProvenance
+open FS.GG.Governance.Config
+
+module ProviderLoaderFixture =
+    let digest (bytes: byte array) = ProviderCatalogIntegrity.digest bytes
+    let parameter key : ProviderCatalog.Parameter =
+        {
+            Key = key
+            Kind = ProviderCatalog.String
+            Required = true
+            Prompt = key
+            Help = key
+            Default = Some key
+            Values = []
+            Validation =
+                {
+                    NonEmpty = true
+                    MinLength = 1
+                    MaxLength = 100
+                    AllowedValues = []
+                }
+        }
+
+
+    let command: Provider.DeclaredCommand =
+        {
+            Executable = "opaque-tool"
+            Arguments = [ ""; "with spaces"; "$(literal);&" ]
+        }
+
+    let descriptor: ProviderCatalog.Descriptor =
+        {
+            Id = "generic-fixture"
+            DisplayName = "Fixture"
+            Help = "Fixture"
+            Language = "opaque"
+            ProductShape = "fixture"
+            DescriptorId = "fixture-descriptor"
+            DescriptorRevision = "revision"
+            DescriptorDigest = digest [||]
+            ContractVersion = "3.0.0"
+            TemplateSource = "opaque-source"
+            TemplateId = "opaque-template"
+            Platforms = [ "fixture-platform" ]
+            Parameters = [ parameter "raw"; parameter "package"; parameter "code" ]
+            Identities =
+                {
+                    RawName = "raw"
+                    PackageIdentity = "package"
+                    CodeIdentifier = "code"
+                }
+            Tools =
+                [
+                    {
+                        Id = "opaque-tool"
+                        Version = "1.2.3"
+                        Platforms = [ "fixture-platform" ]
+                    }
+                ]
+            Capabilities =
+                [
+                    {
+                        Id = "build:build"
+                        Required = true
+                        Platforms = [ "fixture-platform" ]
+                        ToolIds = [ "opaque-tool" ]
+                        EvidenceIds = [ "build-output" ]
+                        Binding =
+                            ProviderCatalog.Command(
+                                command,
+                                {
+                                    WorkingDirectory = "."
+                                    TimeoutSeconds = 2
+                                    CostClass = "cheap"
+                                    EnvironmentIds = [ "fixture-local" ]
+                                }
+                            )
+                    }
+                ]
+            Evidence =
+                [
+                    {
+                        Id = "build-output"
+                        Format = "opaque@literal"
+                        Path = "out/build.json"
+                        Required = true
+                    }
+                ]
+            Skills = []
+        }
+
+    let sealedCatalog () : ProviderCatalog.Catalog =
+        let d = { descriptor with DescriptorDigest = digest (ProviderCatalogIntegrity.descriptorBytes descriptor) }
+        let c = { SchemaVersion = 2; Id = "synthetic-catalog"; Revision = "qualification"; Digest = digest [||]; Providers = [d] }
+        { c with Digest = digest (ProviderCatalogIntegrity.catalogBytes c) }
+
+    let synthetic () =
+        let catalog = sealedCatalog ()
+        let d = catalog.Providers.Head
+
+        let prepared =
+            match resolve catalog d.Id [ "raw", "Awkward name!?" ] with
+            | Ok p -> p
+            | Error e -> failwithf "%A" e
+
+        let hash = "sha256:" + System.String('a', 64)
+
+        let generator: FS.GG.SDD.Artifacts.SchemaVersion.GeneratorVersion =
+            {
+                Id = "synthetic-generator"
+                Version = "1.0.0"
+            }
+
+        let path owner name =
+            {
+                Path = name
+                Owner = owner
+                Sha256 = Some hash
+            }
+
+        let ownership: ScaffoldProvenanceRecord =
+            {
+                SchemaVersion = 1
+                Generator = generator
+                RequiredMinimumCliVersion = None
+                ProviderName = d.Id
+                ProviderContractVersion = d.ContractVersion
+                TemplateRef = d.TemplateSource
+                Outcome = "providerSucceeded"
+                ProducedPaths = [ path GeneratedProduct "src/product.txt" ]
+                MirroredPaths = [ path Mirrored ".codex/skills/product/SKILL.md" ]
+                SddOwnedPaths = [ path Sdd ".fsgg/project.yml" ]
+                DriverPaths = [ path Driver ".agents/skills/driver/SKILL.md" ]
+                GameSkillPaths = [ path GameSkill ".agents/skills/game/SKILL.md" ]
+                RenderingSkillPaths = [ path RenderingSkill ".agents/skills/render/SKILL.md" ]
+                EffectiveParameters = prepared.EffectiveParameters
+            }
+
+        let observation: Observation =
+            {
+                Platform = "fixture-platform"
+                Tools =
+                    [
+                        {
+                            Id = "opaque-tool"
+                            Version = "1.2.3"
+                            Executable = "opaque-tool"
+                        }
+                    ]
+                ConsumedArchiveDigest = hash
+                Transport =
+                    {
+                        Executable = "dotnet"
+                        Version = "10.0.401"
+                    }
+                Invocations =
+                    [
+                        {
+                            Executable = "dotnet"
+                            Arguments = [ "new"; "literal space"; ""; "$(literal)" ]
+                            WorkingRoot = "staging"
+                            WorkingDirectory = "."
+                            EnvironmentRoots = []
+                            TimeoutSeconds = 30
+                            ExitCode = 0
+                        }
+                    ]
+                Result = "succeeded"
+                ProducedPaths =
+                    ownership.ProducedPaths
+                    @ ownership.MirroredPaths
+                    @ ownership.SddOwnedPaths
+                    @ ownership.DriverPaths
+                    @ ownership.GameSkillPaths
+                    @ ownership.RenderingSkillPaths
+            }
+
+        {
+            SchemaVersion = 2
+            Generator = generator
+            Ownership = ownership
+            Observation = observation
+            Declaration =
+                {
+                    RawCatalogDigest = hash
+                    CatalogId = catalog.Id
+                    CatalogRevision = catalog.Revision
+                    CatalogDigest = catalog.Digest
+                    Descriptor = d
+                    EffectiveParameters = prepared.EffectiveParameters
+                    RawProductName = prepared.RawProductName
+                    PackageIdentity = prepared.PackageIdentity
+                    CodeIdentifier = prepared.CodeIdentifier
+                    Archive =
+                        {
+                            Id = "synthetic-package"
+                            Version = "1.0.0"
+                            Digest = hash
+                        }
+                    Policy =
+                        {
+                            Id = "synthetic-policy"
+                            Version = "1.0.0"
+                            Digest = hash
+                        }
+                    EvidenceMap =
+                        {
+                            Id = "synthetic-map"
+                            Version = "1.0.0"
+                            Digest = hash
+                        }
+                    Budgets =
+                        {
+                            RequestedPreflightSeconds = 10
+                            RequestedScaffoldSeconds = 30
+                            AdmittedPreflightSeconds = 10
+                            AdmittedScaffoldSeconds = 30
+                        }
+                    Admission =
+                        {
+                            ContractVersion = "1.0.0"
+                            Platform = "fixture-platform"
+                            RequiredCapabilityIds = []
+                            SemanticOnlyCapabilityIds = []
+                            SupportedPlatforms = [ "fixture-platform" ]
+                            SupportedEnvironmentIds = [ "fixture-local" ]
+                            SupportedFormats = [ { Id = "opaque-format"; Version = "1.0.0" } ]
+                            EvidenceMappings =
+                                [
+                                    {
+                                        Format = "opaque@literal"
+                                        Id = "opaque-format"
+                                        Version = "1.0.0"
+                                    }
+                                ]
+                            Descriptor = d
+                        }
+                }
+        }
+

From ac05952e68992cca528f79f54cf483409024e248 Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 15 Oct 2026 10:55:42 +0200
Subject: [PATCH 2/6] docs(atlas): record provider policy digest API boundary

---
 docs/atlas/catalog.json                                         | 2 +-
 ...1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a.json | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)
 create mode 100644 docs/atlas/records/7637505ba1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a.json

diff --git a/docs/atlas/catalog.json b/docs/atlas/catalog.json
index f8233b1c..7f509010 100644
--- a/docs/atlas/catalog.json
+++ b/docs/atlas/catalog.json
@@ -1 +1 @@
-{"records":["7b7c04c85d989e7136e526e749bfdd35d75ada3890e855a15906c0e400f13f03"],"schema":"fsgg.atlas/1"}
+{"records":["7637505ba1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a","7b7c04c85d989e7136e526e749bfdd35d75ada3890e855a15906c0e400f13f03"],"schema":"fsgg.atlas/1"}
diff --git a/docs/atlas/records/7637505ba1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a.json b/docs/atlas/records/7637505ba1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a.json
new file mode 100644
index 00000000..bbce5be7
--- /dev/null
+++ b/docs/atlas/records/7637505ba1959d7eeda94c4cb039fb17150c473cec3024045d384294f9b74c8a.json
@@ -0,0 +1 @@
+{"citations":[{"path":"src/FS.GG.SDD.Commands/CatalogScaffoldPolicy.fs","repository":"FS-GG/FS.GG.SDD","revision":"c8aea9289a6cc410f076823bf1219a02314f00a7","sha256":"d47db7c167aeb169af86788f85864d72ed428f7d22dac11537294b71b50c9c2f"},{"path":"src/FS.GG.SDD.Commands/ProviderCapabilityAdmission.fsi","repository":"FS-GG/FS.GG.SDD","revision":"c8aea9289a6cc410f076823bf1219a02314f00a7","sha256":"b741374ce237334d806688b13733388e0442821287070f3a1a4cf403fff1ed54"}],"conflictsWith":[],"id":"governance/provider-loader-package-digest-boundary","kind":"dependency","recordedAt":"2026-10-15T08:55:26Z","repository":"FS-GG/FS.GG.Governance","schema":"fsgg.atlas/1","status":"recorded","summary":"Verify ProviderContext selectors accept raw 64-character hexadecimal SHA256, preserving spelling. The retained SDD Commands CatalogScaffoldPolicy.parse API at the cited source instead compares its expectedRawDigest with a lowercase sha256:-prefixed digest of the policy byte array. A consumer must first validate the selected raw digest against the captured bytes, then supply the recomputed prefixed representation to the actual codec. ProviderCapabilityAdmission.request consumes independent Policy, selected platform and original descriptor and returns the complete Config ResolutionRequest; parsing or admission establishes declarations, not execution or policy authority. This is immutable source inspection; it supplies no runtime/package qualification, publication or installed acceptance.","supersedes":[],"tags":["governance","sdd","provider","loader","digest"],"title":"Verify raw digest selectors require adaptation to the SDD package policy codec"}

From 584f447ddd0f1ff9f932f16f9a28132f2919aca2 Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 15 Oct 2026 11:30:41 +0200
Subject: [PATCH 3/6] style: remove provider loader fixture blank EOF line

---
 .../ProviderLoaderFixture.fs                                     | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
index 25d25f2d..c99bba91 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
@@ -248,4 +248,3 @@ module ProviderLoaderFixture =
                         }
                 }
         }
-

From 4bfa8e732e7a54a21dfc460ce4d450f7213b15cc Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 15 Oct 2026 11:40:38 +0200
Subject: [PATCH 4/6] fix: align nested provider loader fixture record update

---
 .../ProviderContextLoaderTests.fs                     | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
index 68a5d58d..78ee0d80 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
@@ -24,11 +24,12 @@ let coherentRecord () =
         | Ok value -> value
         | Error errors -> failtestf "%A" errors
     let original = ProviderLoaderFixture.synthetic ()
-    { original with Declaration =
-        { original.Declaration with
-            Policy = { Id = policy.Identity.Id; Version = policy.Identity.Version; Digest = policy.Identity.Digest }
-            EvidenceMap = { Id = policy.EvidenceMapIdentity.Id; Version = policy.EvidenceMapIdentity.Version; Digest = policy.EvidenceMapIdentity.Digest }
-            Admission = { original.Declaration.Admission with RequiredCapabilityIds = policy.RequiredCapabilityIds } } }
+    { original with
+        Declaration =
+            { original.Declaration with
+                Policy = { Id = policy.Identity.Id; Version = policy.Identity.Version; Digest = policy.Identity.Digest }
+                EvidenceMap = { Id = policy.EvidenceMapIdentity.Id; Version = policy.EvidenceMapIdentity.Version; Digest = policy.EvidenceMapIdentity.Digest }
+                Admission = { original.Declaration.Admission with RequiredCapabilityIds = policy.RequiredCapabilityIds } } }
 let provenanceBytes record =
     match FS.GG.SDD.Artifacts.CatalogScaffoldProvenance.serialize record with
     | Ok text -> bytes text

From bf2a36874ab724addc908ae01c48a7ac24f7d079 Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 15 Oct 2026 11:58:32 +0200
Subject: [PATCH 5/6] build: lock qualified provider loader package closure

---
 .../packages.lock.json                        | 67 ++++++++++++++++++
 .../packages.lock.json                        | 69 +++++++++++++++++++
 2 files changed, 136 insertions(+)

diff --git a/src/FS.GG.Governance.VerifyCommand/packages.lock.json b/src/FS.GG.Governance.VerifyCommand/packages.lock.json
index 80a07748..85bba14c 100644
--- a/src/FS.GG.Governance.VerifyCommand/packages.lock.json
+++ b/src/FS.GG.Governance.VerifyCommand/packages.lock.json
@@ -2,12 +2,79 @@
   "version": 2,
   "dependencies": {
     "net10.0": {
+      "FS.GG.SDD.Artifacts": {
+        "type": "Direct",
+        "requested": "[2.3.0, )",
+        "resolved": "2.3.0",
+        "contentHash": "svdbA3ynClYdVPK8xg4MyWZWHm9xjQX3M+B8NLV5XfH3EwBflVFwff8OfeUvrVJUA8m6jfRGgpXMxuRk2JuDxw==",
+        "dependencies": {
+          "FS.GG.Contracts": "[7.6.0]",
+          "FSharp.Core": "10.1.401",
+          "FsQuint": "[0.1.0]",
+          "YamlDotNet": "18.1.0"
+        }
+      },
+      "FS.GG.SDD.Commands": {
+        "type": "Direct",
+        "requested": "[2.3.0, )",
+        "resolved": "2.3.0",
+        "contentHash": "71+vMRrCQlwpJh34+mThn0tVJKkl+znRHEmPBOQv3tj9DL9IllRryQQYomvWsUEhIGhlNPxE3fCJ+qFPlS9wug==",
+        "dependencies": {
+          "FS.GG.Audio.Skills": "0.1.0",
+          "FS.GG.Contracts": "[7.6.0]",
+          "FS.GG.Drivers": "0.98.0",
+          "FS.GG.Game.Skills": "0.9.0",
+          "FS.GG.Governance.Config": "0.3.0",
+          "FS.GG.Rendering.Skills": "0.2.0",
+          "FS.GG.SDD.Artifacts": "2.3.0",
+          "FS.GG.SDD.Knowledge": "2.3.0",
+          "FSharp.Core": "10.1.401",
+          "FsQuint": "[0.1.0]",
+          "YamlDotNet": "18.1.0"
+        }
+      },
       "FSharp.Core": {
         "type": "Direct",
         "requested": "[10.1.401, )",
         "resolved": "10.1.401",
         "contentHash": "/lvOK51KD8IangBYkfDVna3/HrE/r4VUnX3dI01KDspctoYXmind3POeoYkqWKeXHwiKlf6Hc9TxwSnoSCWcjw=="
       },
+      "FS.GG.Audio.Skills": {
+        "type": "Transitive",
+        "resolved": "0.1.0",
+        "contentHash": "y46khxa4cMAuQ1yYdQTDR+4yR9omo7ZkTkGIVAnrgZGY6xcVQ7JThVheBHkum6rQpqek3ftV/gCjU2sJNR7HEA=="
+      },
+      "FS.GG.Drivers": {
+        "type": "Transitive",
+        "resolved": "0.98.0",
+        "contentHash": "6eIhj85W5Rfo3q8kmDmWj6nvKPI+QGNwnyZ6Xnx8FcWuyeL76Z4S0/kJoYC/CzMkcdud01+8kALHQE6Cn0os7w=="
+      },
+      "FS.GG.Game.Skills": {
+        "type": "Transitive",
+        "resolved": "0.9.0",
+        "contentHash": "qA3f2ypjVVoaNwmwvrBsJx4VFSx1tUZ3zqv+lAd2nNaWL4nA3dNor9rS449+hRBDFr+UAzZnPBzkyrUEUrn+qg=="
+      },
+      "FS.GG.Rendering.Skills": {
+        "type": "Transitive",
+        "resolved": "0.2.0",
+        "contentHash": "VA1vB24HV1vGjjx8ySqZs7gZXVbEKdAsLglnCEhO/LyjN5Vi8gf/R+vE+R5wGxzGG6q6LUv55hDjT4th0WSvoQ=="
+      },
+      "FS.GG.SDD.Knowledge": {
+        "type": "Transitive",
+        "resolved": "2.3.0",
+        "contentHash": "AJdPKGO6ALsV9bZ8b8eRYEMDcNBU4UXSwmASMi2VH7QFJm7VUaZfEKEaqfHrsLxzkGES4ONw15eE7KMAB2bDNQ==",
+        "dependencies": {
+          "FSharp.Core": "10.1.401"
+        }
+      },
+      "FsQuint": {
+        "type": "Transitive",
+        "resolved": "0.1.0",
+        "contentHash": "S1dCVHdcLRdXmZnjCOk+nJLhjO3acz705bEeQm2cBrwxiEsDpVj7PD8tECcKo/Bzpbw5ZOI4bLMWdlqSkISsbg==",
+        "dependencies": {
+          "FSharp.Core": "10.1.302"
+        }
+      },
       "Spectre.Console.Ansi": {
         "type": "Transitive",
         "resolved": "0.57.2",
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/packages.lock.json b/tests/FS.GG.Governance.VerifyCommand.Tests/packages.lock.json
index f9f45ed4..ebad9a19 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/packages.lock.json
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/packages.lock.json
@@ -54,6 +54,42 @@
           "Microsoft.Testing.Platform.MSBuild": "2.3.3"
         }
       },
+      "FS.GG.Audio.Skills": {
+        "type": "Transitive",
+        "resolved": "0.1.0",
+        "contentHash": "y46khxa4cMAuQ1yYdQTDR+4yR9omo7ZkTkGIVAnrgZGY6xcVQ7JThVheBHkum6rQpqek3ftV/gCjU2sJNR7HEA=="
+      },
+      "FS.GG.Drivers": {
+        "type": "Transitive",
+        "resolved": "0.98.0",
+        "contentHash": "6eIhj85W5Rfo3q8kmDmWj6nvKPI+QGNwnyZ6Xnx8FcWuyeL76Z4S0/kJoYC/CzMkcdud01+8kALHQE6Cn0os7w=="
+      },
+      "FS.GG.Game.Skills": {
+        "type": "Transitive",
+        "resolved": "0.9.0",
+        "contentHash": "qA3f2ypjVVoaNwmwvrBsJx4VFSx1tUZ3zqv+lAd2nNaWL4nA3dNor9rS449+hRBDFr+UAzZnPBzkyrUEUrn+qg=="
+      },
+      "FS.GG.Rendering.Skills": {
+        "type": "Transitive",
+        "resolved": "0.2.0",
+        "contentHash": "VA1vB24HV1vGjjx8ySqZs7gZXVbEKdAsLglnCEhO/LyjN5Vi8gf/R+vE+R5wGxzGG6q6LUv55hDjT4th0WSvoQ=="
+      },
+      "FS.GG.SDD.Knowledge": {
+        "type": "Transitive",
+        "resolved": "2.3.0",
+        "contentHash": "AJdPKGO6ALsV9bZ8b8eRYEMDcNBU4UXSwmASMi2VH7QFJm7VUaZfEKEaqfHrsLxzkGES4ONw15eE7KMAB2bDNQ==",
+        "dependencies": {
+          "FSharp.Core": "10.1.401"
+        }
+      },
+      "FsQuint": {
+        "type": "Transitive",
+        "resolved": "0.1.0",
+        "contentHash": "S1dCVHdcLRdXmZnjCOk+nJLhjO3acz705bEeQm2cBrwxiEsDpVj7PD8tECcKo/Bzpbw5ZOI4bLMWdlqSkISsbg==",
+        "dependencies": {
+          "FSharp.Core": "10.1.302"
+        }
+      },
       "Microsoft.ApplicationInsights": {
         "type": "Transitive",
         "resolved": "2.23.0",
@@ -698,6 +734,8 @@
           "FS.GG.Governance.SurfaceChecks.Dispatch": "[0.1.0, )",
           "FS.GG.Governance.ValidationMatrix": "[0.1.0, )",
           "FS.GG.Governance.VerifyJson": "[0.1.0, )",
+          "FS.GG.SDD.Artifacts": "[2.3.0, )",
+          "FS.GG.SDD.Commands": "[2.3.0, )",
           "FSharp.Core": "[10.1.401, )"
         }
       },
@@ -730,6 +768,37 @@
           "FSharp.Core": "10.1.401"
         }
       },
+      "FS.GG.SDD.Artifacts": {
+        "type": "CentralTransitive",
+        "requested": "[2.3.0, )",
+        "resolved": "2.3.0",
+        "contentHash": "svdbA3ynClYdVPK8xg4MyWZWHm9xjQX3M+B8NLV5XfH3EwBflVFwff8OfeUvrVJUA8m6jfRGgpXMxuRk2JuDxw==",
+        "dependencies": {
+          "FS.GG.Contracts": "[7.6.0]",
+          "FSharp.Core": "10.1.401",
+          "FsQuint": "[0.1.0]",
+          "YamlDotNet": "18.1.0"
+        }
+      },
+      "FS.GG.SDD.Commands": {
+        "type": "CentralTransitive",
+        "requested": "[2.3.0, )",
+        "resolved": "2.3.0",
+        "contentHash": "71+vMRrCQlwpJh34+mThn0tVJKkl+znRHEmPBOQv3tj9DL9IllRryQQYomvWsUEhIGhlNPxE3fCJ+qFPlS9wug==",
+        "dependencies": {
+          "FS.GG.Audio.Skills": "0.1.0",
+          "FS.GG.Contracts": "[7.6.0]",
+          "FS.GG.Drivers": "0.98.0",
+          "FS.GG.Game.Skills": "0.9.0",
+          "FS.GG.Governance.Config": "0.3.0",
+          "FS.GG.Rendering.Skills": "0.2.0",
+          "FS.GG.SDD.Artifacts": "2.3.0",
+          "FS.GG.SDD.Knowledge": "2.3.0",
+          "FSharp.Core": "10.1.401",
+          "FsQuint": "[0.1.0]",
+          "YamlDotNet": "18.1.0"
+        }
+      },
       "FSharp.Compiler.Service": {
         "type": "CentralTransitive",
         "requested": "[43.12.401, )",

From e2a656b0482f487e10c1e90c375f897b738926ef Mon Sep 17 00:00:00 2001
From: EHotwagner <ehotwagner@gmail.com>
Date: Thu, 22 Oct 2026 10:44:03 +0200
Subject: [PATCH 6/6] Cover provider loader refusal branches and refresh stale
 package-availability text

Add decode refusal tests (legacy schema-1 provenance, budget ceilings, unmapped
environment), tighten the Program planning exit assertion, and replace text that
still described SDD 2.3.0 as an unpublished local candidate.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
---
 Directory.Packages.local.props                |  2 +-
 ...ernance-423-neutral-capability-bindings.md | 14 +++++----
 .../FS.GG.Governance.VerifyCommand.fsproj     |  3 +-
 .../ProviderContextLoaderTests.fs             | 30 ++++++++++++++++++-
 .../ProviderLoaderFixture.fs                  |  2 ++
 5 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/Directory.Packages.local.props b/Directory.Packages.local.props
index c237bbf4..b59dc767 100644
--- a/Directory.Packages.local.props
+++ b/Directory.Packages.local.props
@@ -36,7 +36,7 @@
        (see nuget.config). Contract id: fsgg-contracts (registry/dependencies.yml). -->
   <ItemGroup>
     <PackageVersion Include="FS.GG.Contracts" Version="7.6.0" />
-    <!-- Local retained candidate only; package qualification and public availability remain separate. -->
+    <!-- SDD 2.3.0 is published (FS-GG/FS.GG.SDD#1113) from the retained candidate used by the explicit provider loader; each lock file pins its content hash. -->
     <PackageVersion Include="FS.GG.SDD.Commands" Version="2.3.0" />
     <PackageVersion Include="FS.GG.SDD.Artifacts" Version="2.3.0" />
   </ItemGroup>
diff --git a/docs/roadmaps/governance-423-neutral-capability-bindings.md b/docs/roadmaps/governance-423-neutral-capability-bindings.md
index cc0e561f..e6de1d97 100644
--- a/docs/roadmaps/governance-423-neutral-capability-bindings.md
+++ b/docs/roadmaps/governance-423-neutral-capability-bindings.md
@@ -365,8 +365,9 @@ with the Atlas helper and verify its immutable source citations before reuse.
 
 Source preparation targets the retained SDD Commands/Artifacts 2.3.0 candidate from
 run `37951954780`, artifact `11626413573`, source
-`c8aea9289a6cc410f076823bf1219a02314f00a7`. Selection is not package qualification
-or public availability. The package-backed adapter decodes immutable observations from the
+`c8aea9289a6cc410f076823bf1219a02314f00a7`. As of 2026-10-22 SDD 2.3.0 is published from that
+exact candidate (FS-GG/FS.GG.SDD#1113) and a cold locked restore of the org feed matches the
+committed lock hashes and the retained archive digests for Commands, Artifacts and Knowledge. The package-backed adapter decodes immutable observations from the
 original Ready capture session, strictly parses schema-2 provenance and independently selected
 policy, binds policy/platform/admission correspondence, and recomputes the whole Config request
 before catalog selection, cache or execution. Literal argv stays typed throughout.
@@ -381,7 +382,10 @@ availability. Legacy invocations retain the existing interpreter path.
 Focused source controls cover actual package codecs, raw digests, strict UTF-8/schema refusal,
 independent policy/platform correspondence and the Program-to-planning join. Fixtures are
 synthetic declarations and observations, not execution evidence. Local CLR, restore/lock
-regeneration, compilation and test execution were held under the programme resource limit;
-these controls remain unverified. Package-only qualification, exact-head hosted validation,
-physical capture acceptance, production owner integration, source/evidence revalidation and
+regeneration, compilation and test execution were held under the programme resource limit when
+this section was first written; they have since run (2026-10-22: locked restore, build, and the
+Verify suite in Debug and Release, with the hosted gate set on the reviewed head). The
+`ProviderContextLoader.load` capture-readiness selection and the `CapabilityBindings.Rejected`
+branch of `decode` remain without direct tests until a caller-owned ready capture fixture exists.
+Package-only qualification, physical capture acceptance, production owner integration, source/evidence revalidation and
 the real SDD-to-Verify/GateExecution journey remain open. C2 remains unchecked.
diff --git a/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj b/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
index f46c2d64..c72a780b 100644
--- a/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
+++ b/src/FS.GG.Governance.VerifyCommand/FS.GG.Governance.VerifyCommand.fsproj
@@ -12,7 +12,8 @@
        F052 freshness/reuse/execution cores — PLUS the new VerifyJson (NOT AuditJson; verify projects its own
        document). There is NO `Declaration` adapter and NO new sensing (the F055 release declaration surface
        was release-specific); "validate generated views/evidence currency" IS the existing F043/F041
-       evaluation surfaced and acted on. It adds NO new third-party dependency: git sensing is delegated to
+       evaluation surfaced and acted on. Its only package references are the first-party FS.GG.SDD Commands/Artifacts 2.3.0 pair used by the explicit
+       provider loader (ProviderContextLoader); it adds NO new third-party dependency: git sensing is delegated to
        Snapshot, catalog reads to Config, enforcement/rollup to Enforcement/Ship, serialization to VerifyJson;
        the only new impure primitives are a `System.IO` write (the ArtifactWriter port) and `Environment.Exit`
        at the Program edge — both BCL. No YamlDotNet.
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
index 78ee0d80..8ffe7547 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderContextLoaderTests.fs
@@ -86,6 +86,33 @@ let tests = testList "ProviderContextLoader" [
         match ProviderContextLoader.decode (selection provenance policyBytes) provenance policyBytes with
         | Error errors -> Expect.isNonEmpty errors "actual package refusal"
         | Ok _ -> failtest "Unsupported schema accepted")
+    testCase "legacy schema-1 provenance is refused and never becomes legacy mode" (fun _ ->
+        let provenance = bytes (FS.GG.SDD.Artifacts.ScaffoldProvenance.serialize (coherentRecord ()).Ownership)
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        ProviderContextLoader.decode selected provenance coherentPolicyBytes |> refusedAt "$.provenance.schemaVersion")
+    testCase "recorded admission budgets above the independent policy ceilings are refused" (fun _ ->
+        let record = coherentRecord ()
+        let budgets = { record.Declaration.Budgets with AdmittedPreflightSeconds = 31 }
+        let provenance = provenanceBytes { record with Declaration = { record.Declaration with Budgets = budgets } }
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        ProviderContextLoader.decode selected provenance coherentPolicyBytes |> refusedAt "$.policy.budgets")
+    testCase "binding to an environment the independent policy does not map is refused at request admission" (fun _ ->
+        let record = coherentRecord ()
+        let declared = record.Declaration.Descriptor.Capabilities.Head
+        let binding =
+            match declared.Binding with
+            | Fsgg.ProviderCatalog.Command(command, settings) ->
+                Fsgg.ProviderCatalog.Command(command, { settings with EnvironmentIds = [ "unselected-environment" ] })
+            | other -> other
+        let changed = { record.Declaration.Descriptor with Capabilities = [ { declared with Binding = binding } ] }
+        let descriptor = ProviderLoaderFixture.reseal changed
+        let provenance = provenanceBytes { record with Declaration = { record.Declaration with Descriptor = descriptor; Admission = { record.Declaration.Admission with Descriptor = descriptor } } }
+        let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
+        match ProviderContextLoader.decode selected provenance coherentPolicyBytes with
+        | Ok _ -> failtest "An unmapped environment must not produce a request"
+        | Error errors ->
+            Expect.isNonEmpty errors "rejected"
+            Expect.isTrue (errors |> List.exists (fun d -> d.Path = "$.descriptor.capabilities.build:build.environments")) (sprintf "located admission diagnostic: %A" errors))
     testCase "Program provider path decodes actual bytes and drives nonpassing planning without legacy execution" (fun _ ->
         let provenance = provenanceBytes (coherentRecord ())
         let selected = { selection provenance coherentPolicyBytes with Platform = "fixture-platform" }
@@ -109,7 +136,8 @@ let tests = testList "ProviderContextLoader" [
                "--provider-platform"; selected.Platform; "--paths"; "src/a.fs" |]
         let code = Program.runWithProviderLoader load (fun _ -> ports) ignore actualArgv
         Expect.equal loads 1 "single package-backed admission"
-        Expect.isTrue (code = 1 || code = 3) "planning refuses or remains blocked, never passes"
+        Expect.notEqual code 0 "planning never passes"
+        Expect.isTrue (code = 1 || code = 3) "planning refuses or remains blocked"
         Expect.isFalse execution "no execution"
         Expect.isFalse cache "no legacy reuse"
         Expect.isEmpty cap.Writes "no passing artifact")
diff --git a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
index c99bba91..ded9f96f 100644
--- a/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
+++ b/tests/FS.GG.Governance.VerifyCommand.Tests/ProviderLoaderFixture.fs
@@ -100,6 +100,8 @@ module ProviderLoaderFixture =
             Skills = []
         }
 
+    let reseal (d: ProviderCatalog.Descriptor) = { d with DescriptorDigest = digest (ProviderCatalogIntegrity.descriptorBytes d) }
+
     let sealedCatalog () : ProviderCatalog.Catalog =
         let d = { descriptor with DescriptorDigest = digest (ProviderCatalogIntegrity.descriptorBytes descriptor) }
         let c = { SchemaVersion = 2; Id = "synthetic-catalog"; Revision = "qualification"; Digest = digest [||]; Providers = [d] }