Skip to content

fix(policy): check mcp.transport.allow on the effective MCP transport - #3788

Merged
Daniel Meppiel (danielmeppiel) merged 11 commits into
mainfrom
danielmeppiel-mcp-transport-policy
Nov 18, 2026
Merged

Daniel Meppiel (danielmeppiel) merged 11 commits into
mainfrom
danielmeppiel-mcp-transport-policy

Conversation

@danielmeppiel

@danielmeppiel Daniel Meppiel (danielmeppiel) commented Nov 17, 2026 •

Copy link
Copy Markdown
Collaborator

Description

TL;DR. Org policy mcp.transport.allow now checks the transport APM will actually write, not only the transport: in apm.yml. Registry servers without a declared transport (for example an SSE remote) are looked up and checked, and http now equals streamable-http on both sides. apm install, apm install --mcp, apm update and apm audit --ci agree, and a blocked server is rejected before any MCP config or apm.yml write.

Important

Release note: this can newly block installs of registry MCP servers whose transport is not allowed, or that cannot be resolved. The remedy is to declare transport: for the server in apm.yml or to update the policy.

Note

Builds on #3789 (merged): the policy projection extends that owner module (mcp_transport.py) and reuses install's fetch-then-overlay step.

Problem (WHY)

  • policy/policy_checks.py compared only mcp.transport from the manifest: if mcp.transport and mcp.transport not in allowed_transports. A registry server has no declared transport, so its SSE remote was never checked (finding F28).
  • Spellings compared raw: allow: [stdio, http] did not match a declared streamable-http, and vice versa.
  • Before this PR, apm install --mcp io.example/sse-server under allow: [stdio, http] wrote the SSE server to Copilot config (reproduced by the new lifecycle test on the old code).

Approach (WHAT)

Concern Decision
Vocabulary Owner mcp_transport.py adds canonical_transport_name(s) (http -> streamable-http) and server_write_transports(server_info).
Policy parse mcp.transport.allow is canonicalized once in policy/parser.py; unknown names warn; extends: intersects canonical names.
Effective transport Registry servers: lookup in the same registry install uses, manifest overlay applied (a declared transport: narrows only when the server offers it), package = stdio, remote = its transport (adapter selected_remote), both reported when both exist. Unresolvable registry servers are unknown even when declared. Self-defined servers: declared, offline.
Unresolvable Check fails with effective transport unknown (<reason>) naming unreachable / not found; enforcement: warn downgrades through the shared enforcement path, before any write.
Cost Lookup only when mcp.transport.allow is set; per-process memo so gate + pre-write preflight query once. Tests stay off the public registry via an autouse fixture on the resolver's _registry_client seam.

Implementation (HOW)

File Change
src/apm_cli/mcp_transport.py Owner from #3789, extended with the policy projection: canonical_transport_name(s), POLICY_TRANSPORTS, UnresolvedTransport, server_write_transports (remote chosen by MCPClientAdapter.selected_remote).
src/apm_cli/integration/mcp_transport_resolution.py New resolve_effective_mcp_transports(mcp_deps): first-wins dedupe, groups by install's _registry_group_key, overlays through install's _overlaid_server_infos, memoizes lookups; policy_checked_registry_info hands install the judged snapshot.
src/apm_cli/policy/policy_checks.py Check 9 takes `{name: frozenset[canonical]
src/apm_cli/policy/parser.py, schema.py Canonical allow list + unknown-name warning.
src/apm_cli/install/mcp/command.py, commands/install.py --mcp preflight runs inside registry_env_override, so it resolves against the --registry endpoint before apm.yml is written.
scripts/architecture_linter/checks/install_policy_mcp_transport.py + owner record Guard install-deployment-policy-mcp-transport-projection: no raw .transport / transport_type / "transport" key reads under policy/ (parser excepted for the schema key); required routing needles. MutationCase added.
Docs enterprise/policy-reference.md (effective-transport rules, both-sides check, transport: remedy), reference/policy-schema.md, apm-usage governance.md, CHANGELOG.

Diagram

Every policy caller reaches the transport check through the same seam, which resolves canonical values from the owner before judging them.

flowchart LR
    A["install / install --mcp / update / audit --ci"] --> B["run_dependency_policy_checks"]
    B -->|"mcp.transport.allow set"| C["resolve_effective_mcp_transports"]
    C -->|"declared transport"| D["canonical name, offline"]
    C -->|"registry, undeclared"| E["registry lookup + overlay"]
    E --> F["server_write_transports (owner)"]
    D --> G["_check_mcp_transport vs canonical allow"]
    F --> G
    G -->|"blocked"| H["no MCP config or apm.yml write"]
Loading

Trade-offs

  • Both sides for dual servers. Copilot-family adapters prefer a remote, VS Code/Codex prefer a package, so the written transport depends on target. Checking both is conservative; transport: narrows it.
  • Declared transport narrows, never masks (panel + Copilot folds; the earlier design condition that declared registry transports resolve offline was withdrawn by the captain): MCPIntegrator._apply_overlay narrows remotes only when the server offers the declared transport, otherwise install writes the registry remote (an SSE-only server declaring transport: http gets its SSE remote). So a registry server is always judged on registry data: transport: stdio on a remote-only server is judged on the remote, and an unresolvable registry server stays unknown even with a declaration. The violation says so: <name>: effective transport unknown (<reason>); cannot check it against allowed [..]. Check the server name and registry URL, or make the MCP registry reachable, then retry. A declared 'transport:' cannot stand in: install writes the transport the registry serves. Cost: audit --ci with mcp.transport.allow needs the MCP registry for registry servers.
  • Fail closed on unknown. An unreachable registry fails the check in block mode; install would fail there anyway, and the message names the offline remedy.
  • No lockfile field. Audit resolves via the registry instead of recording transports in apm.lock.yaml, avoiding a lockfile schema change.
  • Lookup in policy seam vs per caller. One lazy lookup inside run_dependency_policy_checks guarantees parity across all callers at the cost of a policy -> integration import (precedent: policy/ci_checks.py).

Follow-ups

Benefits

  1. Registry SSE remotes are blocked under allow: [stdio, streamable-http] (previously allowed).
  2. http / streamable-http compare equal in policy and manifest.
  3. Four commands give one verdict; a blocked --mcp leaves apm.yml byte-identical.
  4. Zero registry calls for users without mcp.transport.allow.

Issue and approved scope

Issue: Fixes #3764

Human scope-approval comment: #3764 (comment)

Does this PR complete the issue, or what remains? It delivers the record's Done-when in full. Follow-up #3822 tracks a warn-mode reporting improvement outside the Done-when.

Type of change

  • Bug fix
  • New feature
  • Documentation
  • Maintenance / refactor

Testing

  • Tested locally
  • All existing tests pass (affected suites; see below)
  • Added tests for new functionality (if applicable)

Scenario evidence

# Scenario (user promise) Principle(s) Test(s) proving it Type
1 A registry SSE remote is blocked under allow: [stdio, http] by install --mcp (apm.yml unchanged) and install (no MCP config), and audit --ci fails mcp-transport Governed by policy tests/integration/test_mcp_transport_policy_lifecycle.py::test_registry_sse_remote_blocked_before_any_write e2e (real binary, local registry)
2 A compliant streamable-http registry remote installs and audit passes Governed by policy, DevX tests/integration/test_mcp_transport_policy_lifecycle.py::test_registry_streamable_http_remote_passes e2e
3 transport: http picks the allowed remote of a server offering sse and streamable-http; a declared transport narrows a dual server but cannot mask a remote-only one; self-defined resolves offline Governed by policy, Secure by default tests/unit/integration/test_mcp_transport_resolution.py::TestDeclaredTransport unit
4 Unresolvable registry server (even with a declared transport:) fails with its reason in install --mcp (before any apm.yml write) and audit --ci; enforcement: warn downgrades it to a warning DevX, Governed by policy tests/integration/test_mcp_transport_policy_lifecycle.py::test_unreachable_registry_blocks_with_remedy, tests/unit/integration/test_mcp_transport_resolution.py::TestUnresolvedTransport, tests/unit/install/test_mcp_preflight_policy.py::TestTransportUnknownUnderWarn e2e + unit
5 Parser canonicalizes once; inheritance intersects canonical names Governed by policy tests/unit/policy/test_parser.py::TestMcpTransportAllowCanonicalization unit
6 Guard catches a raw declared-transport read in check 9 Governed by policy tests/integration/test_architecture_owner_rule_mutations.py (install-deployment-policy-mcp-transport-projection) integration

Regression traps: scenario 1 and test_registry_sse_remote_blocked fail on the pre-fix policy_checks.py (verified by reverting it locally). Scenario 4 fails when the declared-transport offline fallback is restored in the resolver (mutation run).

Validation commands and results (head 42ec6fd, rebased on main 733a4ac)
  • uvx ruff@0.15.12 check / format --check (src, tests, architecture linter, symlink probe) -- passed
  • python -m pylint --disable=all --enable=R0801 --min-similarity-lines=10 --fail-on=R0801 ... -- 10.00/10
  • bash scripts/lint-auth-signals.sh -- clean
  • bash scripts/lint-architecture-boundaries.sh -- exit 0; YAML I/O, 2100-line and relative_to guards -- clean
  • pytest -p no:xdist tests/unit/policy tests/unit/install/test_mcp_preflight_policy.py tests/unit/install/test_transitive_mcp_policy.py tests/integration/test_wave7_policy_registry_coverage.py -- 1715 passed, 1 xfailed
  • pytest -p no:xdist tests/unit/integration/test_mcp_transport_resolution.py -- 27 passed; tests/unit/test_install_command.py -- 134 passed; tests/unit/test_mcp_integrator_install_hermetic.py tests/unit/integration/test_mcp_per_dep_registry.py -- 29 passed
  • pytest -p no:xdist tests/integration/test_architecture_owner_rule_mutations.py -k mcp_transport -- 3 passed
  • APM_E2E_TESTS=1 APM_BINARY_PATH=.venv/bin/apm pytest -p no:xdist tests/integration/test_mcp_transport_policy_lifecycle.py tests/integration/test_mcp_endpoint_alias_passthrough_lifecycle.py tests/integration/test_target_policy_gate_parity_lifecycle.py -- 31 passed
  • CI at 42ec6fd -- 27 checks passed, 3 skipped

How to test

  • APM_E2E_TESTS=1 APM_BINARY_PATH=$PWD/.venv/bin/apm uv run --extra dev pytest tests/integration/test_mcp_transport_policy_lifecycle.py -p no:xdist -q
  • uv run --extra dev pytest tests/unit/integration/test_mcp_transport_resolution.py tests/unit/policy/test_parser.py -p no:xdist -q
  • bash scripts/lint-architecture-boundaries.sh

Spec conformance (OpenAPM v0.1)

  • Spec edit
  • Manifest edit
  • Test edit
  • CONFORMANCE.{md,json} regenerated
  • N/A -- this PR does not change OpenAPM-observable behaviour (org policy evaluation only; waiver in commit message).

Co-authored-by: Copilot 223556219+Copilot@users.noreply.github.com

Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel Daniel Meppiel (danielmeppiel) added this to the 0.37.0 milestone Nov 17, 2026
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
… declared

Panel folds for #3788:
- A registry server's declared transport now narrows the check only when
  the registry offers it (same overlay install applies); e.g.
  `transport: stdio` on a remote-only SSE server is judged as sse. The
  declaration is the offline fallback when the registry cannot resolve
  the server. Self-defined servers stay offline.
- Guard also requires the resolver to reuse MCPIntegrator._apply_overlay
  and _build_self_defined_info (install parity).
- Lifecycle: unreachable registry blocks `install --mcp` with the
  `transport:` remedy and fails audit --ci.
- Tests stay off the public registry through the
  mcp_transport_resolution._registry_client seam (autouse fixture).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel

Copy link
Copy Markdown
Collaborator Author

APM Review Panel: ship_with_followups

Closes a silent policy bypass for registry-sourced MCP servers by evaluating transport.allow against the effective (not declared) transport, with lifecycle proof and an architecture guard.

panel-mode=lean; personas=supply-chain-security-expert,test-coverage-expert,python-architect,apm-ceo

All three panelists landed at recommended severity with no blocking-severity findings. Supply-chain surfaced a real parity gap (a declared transport trusted offline could diverge from what install writes), a seam between the policy and install registry lookups, and new audit --ci egress. Test-coverage asked for e2e proof of the unreachable-registry path. The architect asked the guard to also pin the parity-critical MCPIntegrator helpers.

Folded at head 15775c7: registry servers are now always looked up when mcp.transport.allow is set, and a declared transport narrows the check only when the registry offers it (offline fallback only when the registry cannot resolve the server, where install cannot write it either); self-defined servers stay offline. New tests: test_declared_stdio_cannot_mask_remote_only_server (unit) and test_unreachable_registry_blocks_with_remedy (real binary). The guard now requires MCPIntegrator._apply_overlay( and _build_self_defined_info( in the resolver. Unit tests stay off the public registry via an autouse fixture on the resolver's client seam. The design-condition (a) refinement is pending 0.37 captain confirmation.

Deferred, with rationale: the policy-vs-install lookup seam and private-IP/metadata guards on registry egress. A registry is already trusted for url/command today and registry egress already exists in install; both exceed the #3764 scope.

Aligned with: governed by policy (transport.allow now judges the effective canonical transport, registry remotes included); secure by default (unresolvable servers fail closed under block enforcement, with an actionable remedy); portable by manifest (self-defined declarations and the offline fallback keep audit usable without the registry); multi-harness (one canonical vocabulary, http == streamable-http, independent of adapter spelling).

Panel summary

Persona B R N Takeaway
Supply Chain Security Expert 0 3 0 Declared-transport offline trust created a check-write parity gap (folded); lookup seam and audit egress deferred.
Test Coverage Expert 0 1 0 Regression has e2e lifecycle proof; unreachable-registry path needed e2e proof (folded).
Python Architect 0 1 0 Owner placement, single-seam routing and layering are sound; guard should pin parity-critical helpers (folded).

B = blocking-severity findings, R = recommended, N = nits.
Counts are signal strength, not gates. The maintainer ships.

Top 3 follow-ups

  1. [Supply Chain Security Expert] Share one registry resolution between the policy check and the install write. -- Independent lookups leave a window where a non-deterministic registry serves different metadata to policy and install.
  2. [Supply Chain Security Expert] Add private-IP and cloud-metadata guards to registry egress from per-dependency registry: URLs. -- audit --ci now contacts MCP registries when transport.allow is set.
  3. [Python Architect] Promote MCPIntegrator._apply_overlay and _build_self_defined_info to public API. -- They are parity-critical and now pinned by the guard.

Recommendation

The regression is closed, in-scope findings are folded, the lifecycle proof is hermetic, and the lint chain is green. Ship once the 0.37 captain confirms the condition-(a) refinement and the PR is rebased onto the 0.36.1 transport-normalization owner. Track the lookup seam and the egress guard as backlog issues; they harden an existing trust boundary, not a new one.


Full per-persona findings

Supply Chain Security Expert

  • [recommended] Declared transport trusted offline can diverge from the transport install writes at src/apm_cli/integration/mcp_transport_resolution.py
    transport: stdio on a remote-only registry server: the overlay keeps the remote, the adapter writes SSE, policy saw stdio. (Folded.)
  • [recommended] Policy transport resolution and install prevalidation use independent registry lookups at src/apm_cli/integration/mcp_transport_resolution.py
    A purpose-built registry could answer differently within one invocation. (Deferred.)
  • [recommended] audit --ci gains egress to per-dependency registry: URLs at src/apm_cli/integration/mcp_transport_resolution.py
    SimpleRegistryClient has no private-IP or metadata-range guard. (Deferred.)

Test Coverage Expert

  • [recommended] No lifecycle test for the unresolved-transport path (registry unreachable or server not found).
    Proof (missing at): tests/integration/test_mcp_transport_policy_lifecycle.py::test_unreachable_registry_blocks_with_remedy -- proves: with the registry unreachable, install --mcp is rejected with the transport: remedy before any write. [governed-by-policy,devx] (Folded; now passes.)

Python Architect

  • [recommended] Lint guard does not assert parity-critical private-helper calls in the resolver at scripts/architecture_linter/checks/install_policy_mcp_transport.py
    Removing _apply_overlay or _build_self_defined_info from the resolver would silently break install parity. (Folded; public-API promotion deferred.)

This panel is advisory. It does not block merge. Re-apply the
panel-review label after addressing feedback to re-run.


Generated by autopilot-pr-review-worker. This comment is AI-generated and may contain errors.

Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 Changes recommended

Critical inconsistencies in metadata snapshots, transport normalization, and dependency selection can allow disallowed transports to be installed while audit misses violations.

4 open issues
What changed in this PR

This PR addresses #3764 by extending APM’s MCP transport policy checks from manifest declarations to resolved registry metadata, using a shared transport-normalization module.

Changes:

  • Canonicalizes transport names, including the http alias, when parsing policy.
  • Adds effective-transport resolution and passes direct-install registry overrides into policy preflight.
  • Adds architecture guards, regression coverage, and documentation for the stricter enforcement.
File Description
tests/​unit/​scripts/​test_architecture_runner.py Registers the new guard in the expected rule inventory.
tests/​unit/​policy/​test_policy_checks.py Tests canonical, dual, and unresolved transport checks.
tests/​unit/​policy/​test_parser.py Tests aliases, unknown names, and inheritance.
tests/​unit/​integration/​test_mcp_transport_resolution.py Adds hermetic resolver and overlay coverage.
tests/​integration/​test_wave7_policy_registry_coverage.py Updates transport checks to use canonical inputs.
tests/​integration/​test_mcp_transport_policy_lifecycle.py Adds install and audit lifecycle scenarios.
tests/​integration/​test_architecture_owner_rule_mutations.py Tests detection of raw transport reads.
tests/​fixtures/​policy/​test_fixtures_load.py Expects canonical transport names.
tests/​fixtures/​policy/​golden/​parsed-policies.json Updates normalized policy snapshots.
tests/​conftest.py Prevents public registry lookups during tests.
src/​apm_cli/​policy/​schema.py Documents the canonical allow-list representation.
src/​apm_cli/​policy/​policy_checks.py Checks resolved transports and reports unresolved servers.
src/​apm_cli/​policy/​parser.py Normalizes allow lists and warns on unknown names.
src/​apm_cli/​mcp_transport.py Introduces transport vocabulary and metadata projection.
src/​apm_cli/​integration/​mcp_transport_resolution.py Resolves registry metadata, applies overlays, and memoizes lookups.
src/​apm_cli/​install/​mcp/​command.py Applies registry overrides during policy preflight.
src/​apm_cli/​commands/​install.py Passes registry selection into MCP preflight.
scripts/​architecture_linter/​checks/​install_policy_mcp_transport.py Adds the canonical transport-projection guard.
scripts/​architecture_linter/​checks/​install_policy_intent.py Registers the new architecture rule.
packages/​apm-guide/​.apm/​skills/​apm-usage/​governance.md Updates transport-policy guidance and remedies.
docs/​src/​content/​docs/​reference/​policy-schema.md Documents aliases and effective-transport checks.
docs/​src/​content/​docs/​enterprise/​policy-reference.md Explains resolution, enforcement, and failure handling.
CHANGELOG.md Announces stricter transport enforcement and migration guidance.
.apm/​architecture/​owners/​install-deployment.json Records transport-projection ownership and its guard.

Review effort: Balanced

Comment thread src/apm_cli/mcp_transport.py Resolved
Comment thread src/apm_cli/policy/policy_checks.py Resolved
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Copilot review folds for #3788:
- install writes the registry info org policy judged
  (policy_checked_registry_info), so a registry that answers differently
  later cannot change the written transport; guard pins the call.
- transport resolution dedupes MCP deps first-wins, as install does.
- audit --ci checks production and dev MCP servers, as the install gate
  does.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) force-pushed the danielmeppiel-mcp-transport-policy branch from 1e773ca to 5654564 Compare November 17, 2026 18:56
@danielmeppiel
Daniel Meppiel (danielmeppiel) changed the base branch from main to danielmeppiel-t3-p1-mcp-remote-transport November 17, 2026 18:56
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
…allback

Delta panel folds for #3788 (stacked on #3789):
- When the registry could not be read during the policy check, policy
  judges the declared transport and records it; install now re-projects
  the overlaid info it would write and refuses, before any write in the
  group, when the result differs (unverified_policy_fallbacks).
- server_write_transports takes the adapters' remote selector from the
  caller, so the owner module no longer imports the adapter layer; the
  owner record lists the policy symbols and the guard pins the
  definition site and the install refusal.
- Tests: flaky-registry fallback refusal, multi-remote projection,
  every-adapter remote parity, snapshot reuse on a per-dependency
  registry, and `install --mcp --registry` resolving policy against the
  flag's registry (lifecycle).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) changed the base branch from danielmeppiel-t3-p1-mcp-remote-transport to main November 17, 2026 19:16
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
…allback

Delta panel folds for #3788 (stacked on #3789):
- When the registry could not be read during the policy check, policy
  judges the declared transport and records it; install now re-projects
  the overlaid info it would write and refuses, before any write in the
  group, when the result differs (unverified_policy_fallbacks).
- server_write_transports takes the adapters' remote selector from the
  caller, so the owner module no longer imports the adapter layer; the
  owner record lists the policy symbols and the guard pins the
  definition site and the install refusal.
- Tests: flaky-registry fallback refusal, multi-remote projection,
  every-adapter remote parity, snapshot reuse on a per-dependency
  registry, and `install --mcp --registry` resolving policy against the
  flag's registry (lifecycle).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) force-pushed the danielmeppiel-mcp-transport-policy branch from 485321c to ddb2174 Compare November 17, 2026 19:17
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
…allback

Delta panel folds for #3788 (stacked on #3789):
- When the registry could not be read during the policy check, policy
  judges the declared transport and records it; install now re-projects
  the overlaid info it would write and refuses, before any write in the
  group, when the result differs (unverified_policy_fallbacks).
- server_write_transports takes the adapters' remote selector from the
  caller, so the owner module no longer imports the adapter layer; the
  owner record lists the policy symbols and the guard pins the
  definition site and the install refusal.
- Tests: flaky-registry fallback refusal, multi-remote projection,
  every-adapter remote parity, snapshot reuse on a per-dependency
  registry, and `install --mcp --registry` resolving policy against the
  flag's registry (lifecycle).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) force-pushed the danielmeppiel-mcp-transport-policy branch from ddb2174 to b1ca0a4 Compare November 17, 2026 19:21
@danielmeppiel
Daniel Meppiel (danielmeppiel) changed the base branch from main to danielmeppiel-t3-p1-mcp-remote-transport November 17, 2026 19:23
@danielmeppiel

Copy link
Copy Markdown
Collaborator Author

APM Review Panel: ship_with_followups

Delta pass after the rebase onto #3789. The bypass the panel found this round is fixed, and transport.allow now judges what install actually writes.

panel-mode=delta; personas=python-architect,supply-chain-security-expert,test-coverage-expert,apm-ceo

Material delta since the last advisory (15775c7): the PR now sits on #3789. The provisional transport module is gone; the policy projection lives in the #3789 owner module and reuses install's fetch-then-overlay step. Copilot's earlier folds are in (install writes the snapshot policy judged; first-wins dedupe; audit checks dev MCP servers).

Supply-chain found one real bypass. If the registry failed during the policy check, policy approved a server's declared transport. Install then fetched the server again and could write a different, disallowed transport. Fixed at b1ca0a4: policy records each declared-transport fallback, and install refuses, before any write in the group, if what it would write differs. TestDeclaredFallbackIsEnforcedAtInstall fails when the refusal is turned off.

Architect and test-coverage findings were folded as well:

  • The owner module no longer imports the adapter layer; the caller passes in selected_remote.
  • A test runs every adapter and pins the rule that policy checks a superset of what any harness writes.
  • The owner record and guard now cover the policy symbols where they are defined.
  • install --mcp --registry has a lifecycle step proving policy resolves against the flag's registry.
  • The snapshot test now covers default and per-dependency registries with real URL derivation.

Each new test fails when its fix is removed.

Aligned with: governed by policy (the transport written is the transport checked, fallbacks included); secure by default (unresolvable or unverified servers are refused in block mode); portable by manifest (a declared transport: stays the offline remedy); multi-harness (every adapter is checked against the projection).

Panel summary

Persona B R N Takeaway
Python Architect 0 3 0 Owner routing sound; layer inversion and missing definition-site guard folded; private-helper coupling deferred to the owner.
Supply Chain Security Expert 1 1 0 Declared-fallback bypass reproduced and now folded; registry egress guard still open (pre-existing).
Test Coverage Expert 0 3 0 --registry preflight, multi-remote parity and per-dep snapshot parity tests added.

B = blocking-severity findings, R = recommended, N = nits.
Counts are signal strength, not gates. The maintainer ships.

Top 4 follow-ups

  1. [Supply Chain Security Expert] Track hardening of MCP registry egress for per-dependency registry: URLs. -- Pre-existing client behaviour that audit --ci now reaches when transport.allow is set.
  2. [Test Coverage Expert] Get a full green CI run on the head that includes b1ca0a4 once fix(mcp): render remote transports per harness and heal retired shapes #3789 is rebased onto main. -- The last full CI run was green at 5654564; workflows only run for PRs targeting main, and fix(mcp): render remote transports per harness and heal retired shapes #3789 currently conflicts with main.
  3. [Python Architect] Promote _registry_group_key and _overlaid_server_infos to a public module owned by fix(mcp): render remote transports per harness and heal retired shapes #3789, and make the operations=None contract explicit. -- The resolver and install share private helpers.
  4. [Python Architect] Replace the process-global warnings.catch_warnings around overlay projection with a scoped mechanism. -- catch_warnings is not thread-safe.

Recommendation

The blocking bypass is fixed and covered by a test that fails when the fix is removed, and every recommended finding except the two accepted deferrals is folded with tests. Next: rebase #3789 onto main, confirm full CI on the #3788 head, and land #3788 after #3789.


Full per-persona findings

Python Architect

  • [recommended] server_write_transports imported the adapter layer from the leaf owner module at src/apm_cli/mcp_transport.py. (Folded: the selector is passed in, and an every-adapter parity test was added.)
  • [recommended] No owner record or guard covered the policy symbols defined in mcp_transport.py at .apm/architecture/owners/hooks-integrations.json. (Folded: owner record and definition-site needles.)
  • [recommended] Resolver and install import each other's private helpers; operations=None relies on known being complete; the warning filter is process-global, at src/apm_cli/integration/mcp_transport_resolution.py. (Deferred: refactor of the fix(mcp): render remote transports per harness and heal retired shapes #3789 surface.)

Supply Chain Security Expert

  • [blocking] When the registry lookup is unresolved, a declared transport passes policy, then install refetches and can write a disallowed transport, at src/apm_cli/integration/mcp_transport_resolution.py. (Folded at b1ca0a4: install refuses unverified fallbacks before any write.)
  • [recommended] No egress guard on per-dependency registry: URLs, which audit --ci now also reaches. (Deferred: pre-existing registry client behaviour.)

Test Coverage Expert

  • [recommended] install --mcp --registry policy preflight had no test. (Folded: lifecycle step in tests/integration/test_mcp_transport_policy_lifecycle.py.)
  • [recommended] No multi-remote or every-adapter selected_remote parity test. (Folded: TestOwnerProjection.)
  • [recommended] Snapshot test hardcoded the same URL on both sides. (Folded: parametrized over default and per-dep registry with real URL derivation.)

This panel is advisory. It does not block merge. Re-apply the
panel-review label after addressing feedback to re-run.


Generated by autopilot-pr-review-worker. This comment is AI-generated and may contain errors.

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 Changes recommended

Registry recovery can leave apm.yml modified before an HTTP-only policy rejection and can abort installation for warn-only violations instead of preserving warning behavior.

2 open issues
4 resolved since last review

Review effort: Balanced

Base automatically changed from danielmeppiel-t3-p1-mcp-remote-transport to main November 17, 2026 19:39
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
…allback

Delta panel folds for #3788 (stacked on #3789):
- When the registry could not be read during the policy check, policy
  judges the declared transport and records it; install now re-projects
  the overlaid info it would write and refuses, before any write in the
  group, when the result differs (unverified_policy_fallbacks).
- server_write_transports takes the adapters' remote selector from the
  caller, so the owner module no longer imports the adapter layer; the
  owner record lists the policy symbols and the guard pins the
  definition site and the install refusal.
- Tests: flaky-registry fallback refusal, multi-remote projection,
  every-adapter remote parity, snapshot reuse on a per-dependency
  registry, and `install --mcp --registry` resolving policy against the
  flag's registry (lifecycle).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) force-pushed the danielmeppiel-mcp-transport-policy branch from b1ca0a4 to 43b2f19 Compare November 17, 2026 20:41
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Copilot review folds for #3788: the declared-transport fallback let
`install --mcp --transport ...` write apm.yml before the later refusal
fired, and the install-side refusal bypassed enforcement: warn. A
registry server is now always judged on the registry data install
writes from; when the registry cannot resolve it the transport is
unknown, which the shared enforcement path blocks (block) or warns
about (warn) before any write. Self-defined servers still resolve
offline. The install-side refusal is removed.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Takeover folds for #3788: the warn-mode regression now asserts the
`effective transport unknown` violation is recorded with severity warn
(not only that preflight returns), and the check-9 resolver docstring
states that every registry server is looked up, declared or not.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 17, 2026
Delta panel folds (test-coverage-expert) for #3788:
- Unit: a server offering sse and streamable-http remotes is judged on
  the sse remote install writes when undeclared, and `transport: http`
  (or `streamable-http`) picks the allowed remote. Replaces an alias test
  that passed whether or not the alias narrowed anything.
- Lifecycle: `apm audit --ci` with an unreachable registry reports a
  registry server that declares `transport:` as unknown, and
  `enforcement: warn` downgrades that check to a reported warning.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel

Copy link
Copy Markdown
Collaborator Author

APM Review Panel: ship_with_followups

Registry MCP servers are now judged only on registry data, closing the declared-transport bypass in mcp.transport.allow; all three test gaps are pinned at 0fa0ca7.

panel-mode=delta; personas=supply-chain-security-expert,test-coverage-expert,apm-ceo

Delta since the last advisory (head b1ca0a4, now 9cd3c41 after rebase): 43b2f19 (registry servers judged only on registry data; Copilot threads resolved), 150ccca (warn-severity assertion, docstring), and post-panel test folds at 0fa0ca7.

This delta fixes the main supply-chain risk the previous panels left open. Before, if the registry was unreachable, a registry server's declared transport: was trusted when judging policy. But MCPIntegrator._apply_overlay only narrows remotes when one matches the declared transport. So a server that offers only SSE and declares transport: http would still get its SSE remote written. That made the offline judgement a real policy bypass, not just a cosmetic gap. The PR now always resolves registry servers through the registry plus install's own overlay, and fails with 'effective transport unknown' when it cannot. Removing the install-side refusal also routes enforcement back through the shared path, so enforcement: warn behaves consistently. supply-chain-security-expert confirmed that the policy gate and the install write share one snapshot, keyed on the resolved registry URL and the registry group key. It also confirmed that --registry overrides are grouped the same way and that servers with both a package and a remote are checked on both.

The test-coverage-expert findings are now backed by tests, not opinion. All three were folded at 0fa0ca7. The vacuous alias test was replaced with a fixture that offers both SSE and streamable-http. In that test, an undeclared server is flagged on 'sse', and a server declaring http or streamable-http narrows to streamable-http and passes. The real-binary lifecycle test test_unreachable_registry_blocks_with_remedy now makes audit --ci fail a registry server with transport: http while the registry is unreachable. Restoring the old offline fallback in a mutation run makes this test fail, so it catches the reverted bug. The same test switches the org policy to enforcement: warn and asserts that audit --ci passes with the '(enforcement: warn)' suffix and the unknown detail. Validation at 0fa0ca7: ruff clean, 1701 targeted unit tests and 3 lifecycle tests passed.

One trade-off is intentional and documented. With mcp.transport.allow set, audit --ci now needs the MCP registry for every registry server, and declaring transport: no longer lets them be checked offline. I accept it: the default should be secure, and install needs the registry anyway. The CHANGELOG, policy-reference and governance docs say this in the same PR, so the migration story is clear. The remaining open item is the warn-mode gap supply-chain-security-expert found, covered below.

Dissent. The panelists did not disagree. The only open question was between supply-chain-security-expert and the orchestrator's proposal: fold the warn-mode gap now or defer it. I side with deferring. Block mode, which is the secure default, refuses at the gate. The gap only affects users who explicitly chose enforcement: warn, and they already see an 'effective transport unknown' warning. Adding an install-side check without passing the policy object into install's registry group would bring back the problem 43b2f19 just removed: a check that skips the shared enforcement path.

Aligned with: Secure by default: Unresolvable registry servers now fail closed even when they declare transport:. This removes a real bypass in which an SSE-only server could be written while declared as http. Governed by policy: mcp.transport.allow is checked on the transport that would actually be written, using one snapshot for both the gate and the write. enforcement: warn downgrades through the shared path, and both behaviours are pinned by real-binary audit --ci tests. Pragmatic as npm: The new registry requirement for audit --ci comes with an actionable message naming the server, the redacted registry URL and the reason. The CHANGELOG and docs explain the changed remedy.

Panel summary

Persona B R N Takeaway
Supply Chain Security Expert 0 1 0 Delta closes the declared-transport fallback bypass. Failing closed on unresolvable registry servers is the right default. One warn-mode gap: the transport install writes is never judged.
Test Coverage Expert 0 3 0 Delta's main reversions are trapped; the alias test now passes vacuously, and audit --ci with a declared transport plus warn downgrade lack CLI-tier traps.

B = blocking-severity findings, R = recommended, N = nits.
Counts are signal strength, not gates. The maintainer ships.

Top 2 follow-ups

  1. [Supply Chain Security Expert] File a follow-up issue for this case: under enforcement: warn, when a registry server was unknown at the gate and allow is set, the transport install writes is never judged. The install should project the overlaid info and emit a warn-severity violation naming the transport it wrote (mcp_integrator_install.py:366). -- Users on warn mode currently see only a generic 'effective transport unknown' warning, never 'wrote sse'. Block mode is safe. The fix needs the policy object passed into install's registry group so it goes through shared enforcement rather than bringing back the install-side check removed in 43b2f19.
  2. [Test Coverage Expert] When the warn-mode follow-up lands, add a CLI-tier lifecycle test asserting that install under enforcement: warn names the transport it actually wrote. -- The warn downgrade is now pinned for audit --ci, but not for the install write path the follow-up will change.

Recommendation

Mark the PR ready and merge at 0fa0ca7 once CI is green. The delta closes a real bypass, defaults to failing closed, and all three test gaps are pinned in real-binary tests, one of them confirmed by a mutation run. Before merge, open the follow-up issue for the enforcement: warn install-write gap, linked to #3764 and milestoned for the next release, so the deferral is on record rather than silent.


Full per-persona findings

Supply Chain Security Expert

  • [recommended] Under enforcement: warn, a registry server whose transport was unknown at the gate gets a fresh registry fetch at install, and that written transport is never checked against mcp.transport.allow. at src/apm_cli/integration/mcp_integrator_install.py:366
    The memo stores the UnresolvedTransport result, so policy_checked_registry_info returns None. _install_registry_group then fills known from registry_server_cache or operations.batch_fetch_server_info, overlays it and writes it. If the gate lookup failed briefly but the install fetch succeeds, APM writes, for example, an SSE remote that policy never judged. The only signal the user gets is the earlier generic 'effective transport unknown' warning, not 'wrote sse, which is not in allowed [..]'. Block mode is safe because it refuses at the gate. In warn mode, though, the audit trail shows that a transport was unknown, not which transport was written.
    Suggested: When policy_checked_registry_info returns None and mcp.transport.allow is set, run write_transports() on the freshly overlaid server_info_cache[name] before writing, and send a warn-severity logger.policy_violation naming the transport actually written if it is outside the allow list. Add a unit test: the gate lookup raises and the install fetch returns an SSE-only server under warn; assert the warning names 'sse'.

Test Coverage Expert

  • [recommended] test_declared_http_alias_matches_registry_remote passes vacuously, so nothing pins the new 'pick one with transport:' remedy (declared http narrowing to streamable-http) at tests/unit/integration/test_mcp_transport_resolution.py:177
    The replacement uses HTTP_SERVER, which offers only a streamable-http remote, so the effective transport is streamable-http whether or not 'http' maps to streamable-http in MCPIntegrator._apply_overlay. The docs and release note now make 'pick an allowed transport with transport: when the server offers several' the main remedy for registry servers; no test asserts the remedy narrows a server offering both sse and streamable-http remotes.
    Suggested: Add a server with sse and streamable-http remotes, parametrize declared over http and streamable-http, assert the effective transport is streamable-http, and add a negative control where the undeclared server fails on 'sse'.
    Proof (missing at): tests/unit/integration/test_mcp_transport_resolution.py::TestDeclaredTransport::test_declared_alias_narrows_multi_remote_server -- proves: If my org allows http and a registry server offers both sse and http, declaring transport: http in apm.yml lets it install. [governed-by-policy,devx]
    assert resolution.resolve_effective_mcp_transports([dep]) == {MULTI_REMOTE['name']: frozenset({'streamable-http'})}
    Status: folded at 0fa0ca7.
  • [recommended] No real-CLI trap that audit --ci now fails a registry server with a declared transport: when the registry is unreachable at tests/integration/test_mcp_transport_policy_lifecycle.py:228
    The release note announces this as new behavior, but the only trap is a unit test with a hand-built MCPDependency. The lifecycle audit step uses a bare string with no transport:, so it would still pass if audit kept judging declared registry servers offline.
    Suggested: Widen write_manifest to accept dicts, write {'name': _SSE_NAME, 'transport': 'http'}, run audit and assert the mcp-transport check fails with 'effective transport unknown'.
    Proof (missing at): tests/integration/test_mcp_transport_policy_lifecycle.py::test_unreachable_registry_blocks_with_remedy -- proves: apm audit --ci in CI cannot pass a registry MCP server on its declared transport alone while the registry is down. [governed-by-policy,secure-by-default]
    assert 'effective transport unknown' in checks['mcp-transport']['details'][0]
    Status: folded at 0fa0ca7.
  • [recommended] The enforcement: warn downgrade of 'effective transport unknown' is proven only by a unit test with discovery and logger patched at tests/integration/test_mcp_transport_policy_lifecycle.py
    No real-CLI test drives audit --ci under an enforcement: warn policy with an unresolvable registry server and checks that the outcome is a warning, not a failure. _POLICY in the lifecycle test hardcodes enforcement: block.
    Suggested: Reuse the unreachable-registry setup, switch the org policy to enforcement: warn, and assert the mcp-transport check is reported as a warning.
    Proof (passed): tests/unit/install/test_mcp_preflight_policy.py::TestTransportUnknownUnderWarn::test_unresolvable_registry_server_only_warns -- proves: Under enforcement: warn, a registry server whose transport cannot be resolved produces a warning instead of blocking install. [governed-by-policy,devx]
    assert all(c.kwargs.get("severity") == "warn" for c in unknown)
    Status: folded at 0fa0ca7.

This panel is advisory. It does not block merge. Re-apply the
panel-review label after addressing feedback to re-run.


Generated by autopilot-pr-review-worker. This comment is AI-generated and may contain errors.

Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 18, 2026
Delta panel fold (cli-logging-expert) for #3788: the `effective
transport unknown` detail now says what to do (check the server name
and registry URL, or make the MCP registry reachable, then retry) before
the short reason a declared 'transport:' cannot stand in, in short
sentences and with the check's single-quote style.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 18, 2026
The rebase onto main placed the #3788 entry (twice) inside the [0.36.1]
block and duplicated two 0.36.1 entries; keep main's CHANGELOG and add
the current #3788 entry once under [Unreleased].

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel
Daniel Meppiel (danielmeppiel) marked this pull request as ready for review November 18, 2026 06:52
Org policy mcp.transport.allow compared only the transport declared in
apm.yml, so a registry server with no declared transport (for example an
SSE remote) was never checked, and `http` did not match
`streamable-http`.

- mcp_transport.py (owner) gains the policy projection:
  canonical_transport_name(s), POLICY_TRANSPORTS, UnresolvedTransport and
  server_write_transports (package = stdio, the adapter-selected remote =
  its canonical transport, both for dual servers).
- The parser canonicalizes mcp.transport.allow once; inheritance
  intersects canonical names; unknown names warn.
- run_dependency_policy_checks resolves effective transports through
  integration/mcp_transport_resolution.py, which reuses install's
  _registry_group_key and _overlaid_server_infos: registry servers are
  looked up in the registry install uses and judged on the overlaid info
  (a declared transport narrows only when offered; it is the offline
  fallback when the registry cannot resolve the server). Self-defined
  servers resolve offline. Deps dedupe first-wins as install does. The
  lookup runs only when mcp.transport.allow is set; unresolvable servers
  fail with an actionable reason.
- Install writes the registry snapshot policy judged
  (policy_checked_registry_info); `apm install --mcp` runs its preflight
  against the --registry endpoint before apm.yml is written; audit --ci
  checks production and dev MCP servers like the install gate.
- Guard install-deployment-policy-mcp-transport-projection (owner record
  and MutationCase) bans raw transport reads under policy/ and pins the
  routing.

Fixes #3764

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
…allback

Delta panel folds for #3788 (stacked on #3789):
- When the registry could not be read during the policy check, policy
  judges the declared transport and records it; install now re-projects
  the overlaid info it would write and refuses, before any write in the
  group, when the result differs (unverified_policy_fallbacks).
- server_write_transports takes the adapters' remote selector from the
  caller, so the owner module no longer imports the adapter layer; the
  owner record lists the policy symbols and the guard pins the
  definition site and the install refusal.
- Tests: flaky-registry fallback refusal, multi-remote projection,
  every-adapter remote parity, snapshot reuse on a per-dependency
  registry, and `install --mcp --registry` resolving policy against the
  flag's registry (lifecycle).

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot review folds for #3788: the declared-transport fallback let
`install --mcp --transport ...` write apm.yml before the later refusal
fired, and the install-side refusal bypassed enforcement: warn. A
registry server is now always judged on the registry data install
writes from; when the registry cannot resolve it the transport is
unknown, which the shared enforcement path blocks (block) or warns
about (warn) before any write. Self-defined servers still resolve
offline. The install-side refusal is removed.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Takeover folds for #3788: the warn-mode regression now asserts the
`effective transport unknown` violation is recorded with severity warn
(not only that preflight returns), and the check-9 resolver docstring
states that every registry server is looked up, declared or not.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Delta panel folds (test-coverage-expert) for #3788:
- Unit: a server offering sse and streamable-http remotes is judged on
  the sse remote install writes when undeclared, and `transport: http`
  (or `streamable-http`) picks the allowed remote. Replaces an alias test
  that passed whether or not the alias narrowed anything.
- Lifecycle: `apm audit --ci` with an unreachable registry reports a
  registry server that declares `transport:` as unknown, and
  `enforcement: warn` downgrades that check to a reported warning.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Captain fold for #3788: the `effective transport unknown` violation now
explains that a declared `transport:` is not enough for a registry
server, because install writes the transport the registry serves and
`transport:` only picks among the ones it offers. Unit and lifecycle
tests pin the wording.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Delta panel fold (cli-logging-expert) for #3788: the `effective
transport unknown` detail now says what to do (check the server name
and registry URL, or make the MCP registry reachable, then retry) before
the short reason a declared 'transport:' cannot stand in, in short
sentences and with the check's single-quote style.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
The rebase onto main placed the #3788 entry (twice) inside the [0.36.1]
block and duplicated two 0.36.1 entries; keep main's CHANGELOG and add
the current #3788 entry once under [Unreleased].

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
…) pair

main's commands/install.py sits at the 2100-line CI cap; the two new
keyword arguments for the --mcp policy preflight pushed it to 2102.
run_mcp_policy_preflight now takes the (url, source) pair
_resolve_registry_url returns. No behavior change.

apm-spec-waiver: org policy evaluation only; no OpenAPM manifest, lockfile or registry contract change

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
@danielmeppiel

Copy link
Copy Markdown
Collaborator Author

Lane L: main merged for landing

  • Pre-merge head: 42ec6fda9116b8b45e5eafb1fb9aecb9b2
  • Merged origin/main 0199dedf6da524e5e04e2cfcc74a6ed583f3d986 (clean merge; GitHub reported DIRTY only on CHANGELOG.md, which this repo merges with merge=union).
  • New head: a0bf89074304d8c51153d647d338df0eb41c5d4c
  • CHANGELOG: slotted, so queued PRs no longer collide at the section head while landing serially.
  • Lint: ruff check + ruff format --check silent at the new head; CI green at the new head.
  • Owner-touch report regenerated at the new head; every recorded functional test was re-run at that exact head and passed (one process at a time, no xdist).
  • Push: `` (plain push, no force).

This comment was generated by an AI agent (Lane L landing desk) on behalf of Daniel Meppiel (@danielmeppiel).

@danielmeppiel
Daniel Meppiel (danielmeppiel) merged commit 79f3cae into main Nov 18, 2026
30 checks passed
@danielmeppiel
Daniel Meppiel (danielmeppiel) deleted the danielmeppiel-mcp-transport-policy branch November 18, 2026 07:37
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 18, 2026
… SSE heal test (#3877)

* test(mcp): assert the 0.37 effective-transport policy in the registry SSE heal test (#3876)

#3788 made mcp.transport.allow judge the effective registry transport, so
an SSE remote outside the allow list is now blocked before any MCP write.
The heal lifecycle test still asserted the 0.36.1 declared-only contract.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

* docs(changelog): note the heal transport test update (#3877)

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: danielmeppiel <danielmeppiel@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Daniel Meppiel (danielmeppiel) added a commit that referenced this pull request Nov 19, 2026
…idance (#3903)

* docs(changelog): enforce one-line entries in agent and contributor guidance

Make the changelog rule concrete in its single source
(.apm/instructions/changelog.instructions.md): one line, user-visible
effect first, 25 words or fewer, ending with (#PR); breaking changes in
"Breaking changes and upgrade notes" with a one-line migration; never a
second line for the same change; no entry for internal-only PRs; two
good and two bad examples from the current changelog.

cut-release now re-sanitizes the whole [Unreleased] block at release
time (dedupe, condense, Highlights, upgrade notes, ref/credit check).
The delivery and merge autopilot workers, pr-description-skill,
CONTRIBUTING.md, the PR template and the development guide point at
the rule. Generated .github/ and .agents/ copies and apm.lock.yaml
hashes are re-synced with apm install.

Clean the current [Unreleased] block into that shape: drop the long
duplicates of #3765/#3818, #3769, #3788, #3865, #3867, #3873, #3875,
#3882 and the spec lines, fold their user-relevant caveats into the
short lines, and drop test-only #3877.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

* docs(changelog): scope delivery-worker CHANGELOG edits to one task; shorten sanitizer example

Address review: only the task whose files_hint owns CHANGELOG.md edits it
(wave gate forbids shared-file edits across task branches), and the
worked example now fits rule 2 while keeping its caveat and four refs.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: danielmeppiel <danielmeppiel@users.noreply.github.com>
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

[FEATURE] Evaluate mcp.transport.allow on the effective MCP transport

2 participants