Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In @.github/workflows/ci.yml:
- Around line 15-16: CI workflow uses floating action tags and leaves checkout
credentials enabled; replace the three action references actions/checkout@v6,
actions/setup-go@v6, and golangci/golangci-lint-action@v6 with their
corresponding full commit SHAs to pin to immutable versions, and add
persist-credentials: false to each actions/checkout step (the occurrences of
actions/checkout in the file) so the runner does not expose repo credentials to
subsequent steps.

In @.github/workflows/release.yml:
- Around line 17-19: The checkout step using actions/checkout@v6 currently sets
fetch-depth: 0 but leaves credentials persisted; update the checkout step (the
actions/checkout@v6 block) to include persist-credentials: false under the with:
section so the runner does not retain a writable token in local git config (keep
the existing fetch-depth: 0 and add persist-credentials: false alongside it).
- Line 17: Replace the tag-based action references with immutable commit SHAs
for each `uses:` entry (specifically the occurrences of actions/checkout@v6,
actions/setup-go@v6, anchore/sbom-action/download-syft@v0,
sigstore/cosign-installer@v3, and goreleaser/goreleaser-action@v7): look up the
corresponding GitHub repository for each action, find the commit SHA that
matches the tag currently used, and replace the tag (e.g., actions/checkout@v6)
with the full 40-character SHA form (e.g., actions/checkout@<full-sha>) in the
release workflow; ensure you use the exact repo/name@<sha> syntax and verify the
workflow runs successfully after updating.

In @.goreleaser.yml:
- Line 7: Replace the mutating before.hooks command "go mod tidy" with a
non-mutating check such as "go mod verify" in the .goreleaser.yml before.hooks
entry: locate the before.hooks key that currently runs "go mod tidy" and change
it to run "go mod verify" (and keep any "go mod tidy" usage confined to
CI/development enforcement scripts instead of the release hook).

In `@main.go`:
- Around line 114-121: Validate the pdp_url value before using it: parse pdpURL
with net/url.Parse, ensure url.Scheme is exactly "http" or "https", and ensure
url.Hostname() is non-empty (reject empty host or malformed URLs), and return
the existing mcp.NewToolResultError when validation fails. Apply the same checks
to both uses of the pdpURL variable (the initial block that reads
pdp_url/AUTHZEN_PDP_URL and the other occurrence around line 147) so no outbound
requests are made to invalid or non-http(s) targets.
- Around line 179-191: parseJSONArg currently accepts any JSON value; change it
to enforce that the parsed JSON is an object by unmarshaling into a generic
value (v) as it does now and then verifying v is a map[string]any (i.e. JSON
object); if not, return an error like "arg %q must be a JSON object". Apply this
validation in parseJSONArg for the documented AuthZEN args (subject, resource,
action, and optional context) so arrays/scalars are rejected early, and still
return json.RawMessage(s) on success (or nil for missing optional args).
- Around line 160-163: The code uses io.ReadAll(res.Body) in the PDP response
handling (variable raw) which is unbounded and can exhaust memory; replace the
direct io.ReadAll call with a bounded read using an io.LimitReader (or io.CopyN)
capped to a safe maximum (e.g. const maxPdpResponseBytes) before reading, and
handle the case where the body exceeds the limit by returning a proper error via
mcp.NewToolResultError; update the read error path to include both read errors
and the "response too large" condition so mcp.NewToolResultError is used
consistently.

---

Nitpick comments:
In @.github/workflows/ci.yml:
- Line 31: The CI workflow currently pins the linter to "version: latest" which
causes non-reproducible runs; replace the "version: latest" value used for the
golangci-lint step with a specific released tag (e.g., a stable semver like
v1.59.0) so the workflow always uses a known tool version, and update any
related references to the same tag (the "version: latest" literal in the
golangci-lint job/step) to ensure reproducible CI.

In @.github/workflows/release.yml:
- Line 35: The workflow step currently sets the GoReleaser action with the key
"version: latest"; update that to pin a specific released tag (or full SHA) of
the GoReleaser action instead of "latest" so releases are reproducible—locate
the workflow step containing the "version" key and change the value from
"latest" to a concrete tag like a vX.Y.Z release (or immutable commit SHA).

In `@main_test.go`:
- Around line 42-49: The fakePDP test server should assert the outbound HTTP
contract: inside the httptest handler created by fakePDP (the anonymous handler
passed to httptest.NewServer), validate r.Method == "POST" and that
r.Header.Get("Content-Type") contains "application/json", returning a
400/appropriate error if not, then read and json.Unmarshal the body into capture
as before; this ensures calls from evaluate() must be POST with JSON
content-type and will cause the test to fail if evaluate() stops sending proper
AuthZEN POST JSON requests.