apm-cli 0.9.1__tar.gz → 0.9.3__tar.gz

{apm_cli-0.9.1/src/apm_cli.egg-info → apm_cli-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.9.1
+Version: 0.9.3
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -66,9 +66,14 @@ Dynamic: license-file
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code · Cursor · OpenCode · Codex
+GitHub Copilot · Claude Code · Cursor · OpenCode · Codex · Gemini
 
-**[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)**
+**[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)** · **[Roadmap](https://github.com/orgs/microsoft/projects/2304)**
+
+---
+
+> **Portable by manifest. Secure by default. Governed by policy.**
+> One file describes every agent's context; one command reproduces it everywhere; one policy controls what an org will allow.
 
 ## Why APM
 
@@ -101,17 +106,37 @@ git clone <org/repo> && cd <repo>
 apm install    # every agent is configured
 ```
 
-## Highlights
+## The three promises
 
-- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — instructions, skills, prompts, agents, hooks, plugins, and [MCP servers](https://microsoft.github.io/apm/guides/mcp-servers/) declared in `apm.yml` and deployed across every client on install
+### 1. Portable by manifest
+
+One `apm.yml` describes every primitive your agents need — instructions, skills, prompts, agents, hooks, plugins, MCP servers — and `apm install` reproduces the exact same setup across every client on every machine. `apm.lock.yaml` pins the resolved tree the way `package-lock.json` does for npm.
+
+- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — declared once, deployed across Copilot, Claude, Cursor, OpenCode, Codex, Gemini
 - **[Install from anywhere](https://microsoft.github.io/apm/guides/dependencies/)** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, any git host
 - **[Transitive dependencies](https://microsoft.github.io/apm/guides/dependencies/)** — packages can depend on packages; APM resolves the full tree
-- **[Content security](https://microsoft.github.io/apm/enterprise/security/)** — `apm audit` scans for hidden Unicode; `apm install` blocks compromised packages before agents read them
-- **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management and security scanning, then export standard `plugin.json`
-- **[Marketplaces](https://microsoft.github.io/apm/guides/marketplaces/)** — install plugins from curated registries in one command; deployed across all targets, locked, scanned, and [governed by `apm-policy.yaml`](https://microsoft.github.io/apm/enterprise/security/)
+- **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management, then export standard `plugin.json`
+- **[Marketplaces](https://microsoft.github.io/apm/guides/marketplaces/)** — install plugins from curated registries in one command, deployed across all targets and locked
 - **[Pack & distribute](https://microsoft.github.io/apm/guides/pack-distribute/)** — `apm pack` bundles your configuration as a zipped package or a standalone plugin
 - **[CI/CD ready](https://github.com/microsoft/apm-action)** — GitHub Action for automated workflows
 
+### 2. Secure by default
+
+Agent context is executable in effect — a prompt is a program for an LLM. APM treats it that way. Every install scans for hidden Unicode that can hijack agent behavior; the lockfile pins integrity hashes; transitive MCP servers are gated by trust prompts.
+
+- **[Content security](https://microsoft.github.io/apm/enterprise/security/)** — `apm install` blocks compromised packages before agents read them; `apm audit` runs the same checks on demand
+- **[Lockfile integrity](https://microsoft.github.io/apm/enterprise/governance/)** — `apm.lock` records resolved sources and content hashes for full provenance
+- **[MCP trust boundaries](https://microsoft.github.io/apm/guides/mcp-servers/)** — transitive MCP servers require explicit consent
+
+### 3. Governed by policy
+
+`apm-policy.yml` lets a security team say *"these are the only sources, scopes, and primitives this org will allow"* and have every `apm install` enforce it — with tighten-only inheritance from enterprise to org to repo, a published bypass contract, and audit-mode CI gates.
+
+- **[Governance Guide](https://microsoft.github.io/apm/enterprise/governance-guide/)** — the canonical enterprise reference: enforcement points, bypass contract, air-gapped story, failure semantics, rollout playbook
+- **[Policy reference](https://microsoft.github.io/apm/enterprise/policy-reference/)** — every check, every field, every default
+- **[Adoption playbook](https://microsoft.github.io/apm/enterprise/adoption-playbook/)** — staged rollout from warn to block across hundreds of repos
+- **[GitHub rulesets integration](https://microsoft.github.io/apm/integrations/github-rulesets/)** — wire `apm audit --ci` into branch protection
+
 ## Get Started
 
 #### Linux / macOS
@@ -165,7 +190,7 @@ apm marketplace add github/awesome-copilot
 apm install azure-cloud-development@awesome-copilot
 ```
 
-Or add an MCP server (wired into Copilot, Claude, Cursor, Codex, and OpenCode):
+Or add an MCP server (wired into Copilot, Claude, Cursor, Codex, OpenCode, and Gemini):
 
 ```bash
 apm install --mcp io.github.github/github-mcp-server --transport http   # connects over HTTPS

{apm_cli-0.9.1 → apm_cli-0.9.3}/README.md

@@ -4,9 +4,14 @@
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code · Cursor · OpenCode · Codex
+GitHub Copilot · Claude Code · Cursor · OpenCode · Codex · Gemini
 
-**[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)**
+**[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)** · **[Roadmap](https://github.com/orgs/microsoft/projects/2304)**
+
+---
+
+> **Portable by manifest. Secure by default. Governed by policy.**
+> One file describes every agent's context; one command reproduces it everywhere; one policy controls what an org will allow.
 
 ## Why APM
 
@@ -39,17 +44,37 @@ git clone <org/repo> && cd <repo>
 apm install    # every agent is configured
 ```
 
-## Highlights
+## The three promises
 
-- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — instructions, skills, prompts, agents, hooks, plugins, and [MCP servers](https://microsoft.github.io/apm/guides/mcp-servers/) declared in `apm.yml` and deployed across every client on install
+### 1. Portable by manifest
+
+One `apm.yml` describes every primitive your agents need — instructions, skills, prompts, agents, hooks, plugins, MCP servers — and `apm install` reproduces the exact same setup across every client on every machine. `apm.lock.yaml` pins the resolved tree the way `package-lock.json` does for npm.
+
+- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — declared once, deployed across Copilot, Claude, Cursor, OpenCode, Codex, Gemini
 - **[Install from anywhere](https://microsoft.github.io/apm/guides/dependencies/)** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, any git host
 - **[Transitive dependencies](https://microsoft.github.io/apm/guides/dependencies/)** — packages can depend on packages; APM resolves the full tree
-- **[Content security](https://microsoft.github.io/apm/enterprise/security/)** — `apm audit` scans for hidden Unicode; `apm install` blocks compromised packages before agents read them
-- **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management and security scanning, then export standard `plugin.json`
-- **[Marketplaces](https://microsoft.github.io/apm/guides/marketplaces/)** — install plugins from curated registries in one command; deployed across all targets, locked, scanned, and [governed by `apm-policy.yaml`](https://microsoft.github.io/apm/enterprise/security/)
+- **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management, then export standard `plugin.json`
+- **[Marketplaces](https://microsoft.github.io/apm/guides/marketplaces/)** — install plugins from curated registries in one command, deployed across all targets and locked
 - **[Pack & distribute](https://microsoft.github.io/apm/guides/pack-distribute/)** — `apm pack` bundles your configuration as a zipped package or a standalone plugin
 - **[CI/CD ready](https://github.com/microsoft/apm-action)** — GitHub Action for automated workflows
 
+### 2. Secure by default
+
+Agent context is executable in effect — a prompt is a program for an LLM. APM treats it that way. Every install scans for hidden Unicode that can hijack agent behavior; the lockfile pins integrity hashes; transitive MCP servers are gated by trust prompts.
+
+- **[Content security](https://microsoft.github.io/apm/enterprise/security/)** — `apm install` blocks compromised packages before agents read them; `apm audit` runs the same checks on demand
+- **[Lockfile integrity](https://microsoft.github.io/apm/enterprise/governance/)** — `apm.lock` records resolved sources and content hashes for full provenance
+- **[MCP trust boundaries](https://microsoft.github.io/apm/guides/mcp-servers/)** — transitive MCP servers require explicit consent
+
+### 3. Governed by policy
+
+`apm-policy.yml` lets a security team say *"these are the only sources, scopes, and primitives this org will allow"* and have every `apm install` enforce it — with tighten-only inheritance from enterprise to org to repo, a published bypass contract, and audit-mode CI gates.
+
+- **[Governance Guide](https://microsoft.github.io/apm/enterprise/governance-guide/)** — the canonical enterprise reference: enforcement points, bypass contract, air-gapped story, failure semantics, rollout playbook
+- **[Policy reference](https://microsoft.github.io/apm/enterprise/policy-reference/)** — every check, every field, every default
+- **[Adoption playbook](https://microsoft.github.io/apm/enterprise/adoption-playbook/)** — staged rollout from warn to block across hundreds of repos
+- **[GitHub rulesets integration](https://microsoft.github.io/apm/integrations/github-rulesets/)** — wire `apm audit --ci` into branch protection
+
 ## Get Started
 
 #### Linux / macOS
@@ -103,7 +128,7 @@ apm marketplace add github/awesome-copilot
 apm install azure-cloud-development@awesome-copilot
 ```
 
-Or add an MCP server (wired into Copilot, Claude, Cursor, Codex, and OpenCode):
+Or add an MCP server (wired into Copilot, Claude, Cursor, Codex, OpenCode, and Gemini):
 
 ```bash
 apm install --mcp io.github.github/github-mcp-server --transport http   # connects over HTTPS

{apm_cli-0.9.1 → apm_cli-0.9.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.9.1"
+version = "0.9.3"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"

{apm_cli-0.9.1 → apm_cli-0.9.3}/src/apm_cli/adapters/client/copilot.py

@@ -186,17 +186,36 @@ class CopilotClientAdapter(MCPClientAdapter):
         # Check for remote endpoints first (registry-defined priority)
         remotes = server_info.get("remotes", [])
         if remotes:
-            # Use remote endpoint if available
-            remote = remotes[0]  # Take the first remote
-            
-            # All remote servers use http type for proper authentication support
+            # Select the first remote with a non-empty URL; fall back to the
+            # first entry so downstream code still emits the historical empty
+            # URL error path when no remote is usable.
+            remote = self._select_remote_with_url(remotes) or remotes[0]
+
+            # Validate transport_type from registry: default to "http" when
+            # missing/empty, raise ValueError for unsupported values. Mirrors
+            # the VS Code adapter check introduced in PR #656 so registry data
+            # with, e.g. transport_type="grpc" fails loudly instead of silently
+            # producing a garbage config.
+            transport = (remote.get("transport_type") or "").strip()
+            if not transport:
+                transport = "http"
+            elif transport not in ("sse", "http", "streamable-http"):
+                raise ValueError(
+                    f"Unsupported remote transport '{transport}' for Copilot. "
+                    f"Server: {server_info.get('name', 'unknown')}. "
+                    f"Supported transports: http, sse, streamable-http."
+                )
+
+            # Copilot CLI writes "type": "http" for all remote servers so
+            # authentication flows (headers) are consistent regardless of the
+            # underlying transport advertised by the registry.
             config = {
                 "type": "http",
-                "url": remote.get("url", ""),
+                "url": (remote.get("url") or "").strip(),
                 "tools": ["*"],  # Required by Copilot CLI specification
                 "id": server_info.get("id", "")  # Add registry UUID for conflict detection
             }
-            
+
             # Add authentication headers for GitHub MCP server
             server_name = server_info.get("name", "")
             is_github_server = self._is_github_server(server_name, remote.get("url", ""))
@@ -649,6 +668,22 @@ class CopilotClientAdapter(MCPClientAdapter):
         """Legacy method for backward compatibility. Use _resolve_variable_placeholders instead."""
         return self._resolve_variable_placeholders(value, resolved_env, {})
     
+    @staticmethod
+    def _select_remote_with_url(remotes):
+        """Return the first remote entry that has a non-empty URL.
+
+        Args:
+            remotes (list): Candidate remote entries from the registry.
+
+        Returns:
+            dict or None: The first usable remote, or None if none qualify.
+        """
+        for remote in remotes:
+            url = (remote.get("url") or "").strip()
+            if url:
+                return remote
+        return None
+
     def _select_best_package(self, packages):
         """Select the best package for installation from available packages.
         

apm_cli-0.9.3/src/apm_cli/adapters/client/gemini.py

@@ -0,0 +1,271 @@
+"""Gemini CLI implementation of MCP client adapter.
+
+Gemini CLI uses ``.gemini/settings.json`` at the project root with an
+``mcpServers`` key.  Unlike Copilot, Gemini infers transport from which
+key is present (``command`` for stdio, ``url`` for SSE, ``httpUrl`` for
+streamable HTTP) and does not use ``type``, ``tools``, or ``id`` fields.
+
+.. code-block:: json
+
+   {
+     "mcpServers": {
+       "server-name": {
+         "command": "npx",
+         "args": ["-y", "@modelcontextprotocol/server-foo"],
+         "env": { "KEY": "value" }
+       }
+     }
+   }
+
+APM only writes to ``.gemini/settings.json`` when the ``.gemini/``
+directory already exists -- Gemini CLI support is opt-in.
+
+Ref: https://geminicli.com/docs/reference/configuration/
+"""
+
+import json
+import logging
+import os
+from pathlib import Path
+
+from .copilot import CopilotClientAdapter
+from ...core.docker_args import DockerArgsProcessor
+from ...utils.console import _rich_error, _rich_success
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiClientAdapter(CopilotClientAdapter):
+    """Gemini CLI MCP client adapter.
+
+    Inherits Copilot's helper methods for package selection, env-var
+    resolution, and argument processing but fully reimplements
+    ``_format_server_config`` to emit Gemini-valid JSON.
+    """
+
+    supports_user_scope: bool = True
+
+    def get_config_path(self):
+        """Return the path to ``.gemini/settings.json`` in the repository root."""
+        return str(Path(os.getcwd()) / ".gemini" / "settings.json")
+
+    def update_config(self, config_updates):
+        """Merge *config_updates* into the ``mcpServers`` section of settings.json.
+
+        The ``.gemini/`` directory must already exist; if it does not, this
+        method returns silently (opt-in behaviour).
+
+        Preserves all other top-level keys in settings.json (theme, tools,
+        hooks, etc.).
+        """
+        gemini_dir = Path(os.getcwd()) / ".gemini"
+        if not gemini_dir.is_dir():
+            return
+
+        config_path = Path(self.get_config_path())
+        current_config = self.get_current_config()
+        if "mcpServers" not in current_config:
+            current_config["mcpServers"] = {}
+
+        for name, entry in config_updates.items():
+            current_config["mcpServers"][name] = entry
+
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(current_config, f, indent=2)
+
+    def get_current_config(self):
+        """Read the current ``.gemini/settings.json`` contents."""
+        config_path = self.get_config_path()
+        if not os.path.exists(config_path):
+            return {}
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {}
+
+    def _format_server_config(self, server_info, env_overrides=None, runtime_vars=None):
+        """Format server info into Gemini CLI MCP configuration.
+
+        Gemini's schema differs from Copilot's:
+        - No ``type``, ``tools``, or ``id`` fields.
+        - Transport inferred from key: ``command`` (stdio), ``url`` (SSE),
+          ``httpUrl`` (streamable HTTP).
+        - Tool filtering via ``includeTools``/``excludeTools``.
+
+        Args:
+            server_info: Server information from registry.
+            env_overrides: Pre-collected environment variable overrides.
+            runtime_vars: Pre-collected runtime variable values.
+
+        Returns:
+            dict suitable for writing to ``.gemini/settings.json``.
+        """
+        if runtime_vars is None:
+            runtime_vars = {}
+
+        config: dict = {}
+
+        # --- raw stdio (self-defined deps) ---
+        raw = server_info.get("_raw_stdio")
+        if raw:
+            config["command"] = raw["command"]
+            config["args"] = raw["args"]
+            if raw.get("env"):
+                config["env"] = raw["env"]
+                self._warn_input_variables(
+                    raw["env"], server_info.get("name", ""), "Gemini CLI"
+                )
+            return config
+
+        # --- remote endpoints ---
+        remotes = server_info.get("remotes", [])
+        if remotes:
+            remote = self._select_remote_with_url(remotes) or remotes[0]
+
+            transport = (remote.get("transport_type") or "").strip()
+            if not transport:
+                transport = "http"
+            elif transport not in ("sse", "http", "streamable-http"):
+                raise ValueError(
+                    f"Unsupported remote transport '{transport}' for Gemini. "
+                    f"Server: {server_info.get('name', 'unknown')}. "
+                    f"Supported transports: http, sse, streamable-http."
+                )
+
+            url = (remote.get("url") or "").strip()
+            if transport == "sse":
+                config["url"] = url
+            else:
+                config["httpUrl"] = url
+
+            # Registry-supplied headers
+            for header in remote.get("headers", []):
+                name = header.get("name", "")
+                value = header.get("value", "")
+                if name and value:
+                    config.setdefault("headers", {})[name] = (
+                        self._resolve_env_variable(name, value, env_overrides)
+                    )
+
+            if config.get("headers"):
+                self._warn_input_variables(
+                    config["headers"], server_info.get("name", ""), "Gemini CLI"
+                )
+
+            return config
+
+        # --- local packages ---
+        packages = server_info.get("packages", [])
+
+        if not packages:
+            raise ValueError(
+                f"MCP server has no package information or remote endpoints. "
+                f"Server: {server_info.get('name', 'unknown')}"
+            )
+
+        package = self._select_best_package(packages)
+        if not package:
+            return config
+
+        registry_name = self._infer_registry_name(package)
+        package_name = package.get("name", "")
+        runtime_hint = package.get("runtime_hint", "")
+        runtime_arguments = package.get("runtime_arguments", [])
+        package_arguments = package.get("package_arguments", [])
+        env_vars = package.get("environment_variables", [])
+
+        resolved_env = self._resolve_environment_variables(
+            env_vars, env_overrides
+        )
+        processed_rt = self._process_arguments(
+            runtime_arguments, resolved_env, runtime_vars
+        )
+        processed_pkg = self._process_arguments(
+            package_arguments, resolved_env, runtime_vars
+        )
+
+        if registry_name == "npm":
+            config["command"] = runtime_hint or "npx"
+            config["args"] = ["-y", package_name] + processed_rt + processed_pkg
+        elif registry_name == "docker":
+            config["command"] = "docker"
+            if processed_rt:
+                config["args"] = self._inject_env_vars_into_docker_args(
+                    processed_rt, resolved_env
+                )
+            else:
+                config["args"] = DockerArgsProcessor.process_docker_args(
+                    ["run", "-i", "--rm", package_name], resolved_env
+                )
+        elif registry_name == "pypi":
+            config["command"] = runtime_hint or "uvx"
+            config["args"] = [package_name] + processed_rt + processed_pkg
+        elif registry_name == "homebrew":
+            config["command"] = (
+                package_name.split("/")[-1] if "/" in package_name else package_name
+            )
+            config["args"] = processed_rt + processed_pkg
+        else:
+            config["command"] = runtime_hint or package_name
+            config["args"] = processed_rt + processed_pkg
+
+        if resolved_env:
+            config["env"] = resolved_env
+
+        return config
+
+    def configure_mcp_server(
+        self,
+        server_url,
+        server_name=None,
+        enabled=True,
+        env_overrides=None,
+        server_info_cache=None,
+        runtime_vars=None,
+    ):
+        """Configure an MCP server in ``.gemini/settings.json``.
+
+        Delegates to the parent for config formatting, then writes to
+        the Gemini CLI settings file.
+        """
+        if not server_url:
+            _rich_error("server_url cannot be empty", symbol="error")
+            return False
+
+        gemini_dir = Path(os.getcwd()) / ".gemini"
+        if not gemini_dir.is_dir():
+            return True
+
+        try:
+            if server_info_cache and server_url in server_info_cache:
+                server_info = server_info_cache[server_url]
+            else:
+                server_info = self.registry_client.find_server_by_reference(server_url)
+
+            if not server_info:
+                _rich_error(f"MCP server '{server_url}' not found in registry", symbol="error")
+                return False
+
+            if server_name:
+                config_key = server_name
+            elif "/" in server_url:
+                config_key = server_url.split("/")[-1]
+            else:
+                config_key = server_url
+
+            server_config = self._format_server_config(
+                server_info, env_overrides, runtime_vars
+            )
+            self.update_config({config_key: server_config})
+
+            _rich_success(
+                f"Configured MCP server '{config_key}' for Gemini CLI", symbol="success"
+            )
+            return True
+
+        except Exception as e:
+            logger.debug("Gemini MCP configuration failed: %s", e)
+            _rich_error("Failed to configure MCP server for Gemini CLI", symbol="error")
+            return False

{apm_cli-0.9.1 → apm_cli-0.9.3}/src/apm_cli/bundle/lockfile_enrichment.py

@@ -153,6 +153,17 @@ def enrich_lockfile_for_pack(
                 dep["deployed_files"] = filtered
                 all_mappings.update(mappings)
 
+    # Issue #887: strip packaging-time local-content fields from the bundle
+    # lockfile. ``local_deployed_files`` / ``local_deployed_file_hashes``
+    # describe the packager's own repo content, which is intentionally NOT
+    # shipped in the bundle (see packer.py source-local guard). Leaving them
+    # in the bundle lockfile would cause ``LockFile.from_yaml()`` on the
+    # consumer side to synthesize a self-entry whose ``deployed_files`` do
+    # not exist under the bundle source dir, breaking unpacker verification.
+    if isinstance(data, dict):
+        data.pop("local_deployed_files", None)
+        data.pop("local_deployed_file_hashes", None)
+
     # Build the pack: metadata section (after filtering so we know if mapping
     # occurred).
     # Serialize target as a comma-joined string for backward compatibility

{apm_cli-0.9.1 → apm_cli-0.9.3}/src/apm_cli/bundle/packer.py

@@ -80,12 +80,38 @@ def pack_bundle(
 
     # 2. Read apm.yml for name / version / config target
     apm_yml_path = project_root / "apm.yml"
+    skill_md_path = project_root / "SKILL.md"
+    is_hybrid_root = apm_yml_path.exists() and skill_md_path.exists()
     try:
         package = APMPackage.from_apm_yml(apm_yml_path)
         pkg_name = package.name
         pkg_version = package.version or "0.0.0"
         config_target = package.target
 
+        # HYBRID author guard: apm.yml.description and SKILL.md
+        # description serve different consumers (human-facing CLI/search
+        # vs. agent-runtime invocation matcher) and are NOT merged. If
+        # the author shipped a SKILL.md description but left
+        # apm.yml.description blank, the human-facing surfaces (apm view,
+        # apm search, marketplace listings) will degrade silently while
+        # Claude/Copilot still invoke the skill correctly. Warn loudly
+        # at pack time -- this is the publish gate for the AUTHOR.
+        if is_hybrid_root and not package.description and logger:
+            try:
+                import frontmatter as _frontmatter
+                with open(skill_md_path, "r", encoding="utf-8") as _f:
+                    _skill_post = _frontmatter.load(_f)
+                _skill_desc = _skill_post.metadata.get("description")
+            except Exception:
+                _skill_desc = None
+            if _skill_desc:
+                logger.warning(
+                    "apm.yml is missing 'description'. SKILL.md has its own "
+                    "description, but that is for agent invocation -- not "
+                    "for 'apm view' or search. Add a short tagline to "
+                    "apm.yml:  description: \"One-line human summary\""
+                )
+
         # Guard: reject local-path dependencies (non-portable)
         for dep_ref in package.get_apm_dependencies():
             if dep_ref.is_local:
@@ -119,9 +145,15 @@ def pack_bundle(
         if effective_target == "minimal":
             effective_target = "all"
 
-    # 4. Collect deployed_files from all dependencies, filtered by target
+    # 4. Collect deployed_files from all dependencies, filtered by target.
+    #    Skip local-source entries: these include the synthesized root self-entry
+    #    (local_path == ".") and any local-path manifest deps. Local content is
+    #    not portable and is bundled separately via the project's own files
+    #    (or rejected outright at L89-97 for manifest-declared local deps).
     all_deployed: List[str] = []
     for dep in lockfile.get_all_dependencies():
+        if dep.source == "local":
+            continue
         all_deployed.extend(dep.deployed_files)
 
     filtered_files, path_mappings = _filter_files_by_target(all_deployed, effective_target)

{apm_cli-0.9.1 → apm_cli-0.9.3}/src/apm_cli/cli.py

@@ -20,6 +20,7 @@ from apm_cli.commands.audit import audit
 from apm_cli.commands.compile import compile as compile_cmd
 from apm_cli.commands.config import config
 from apm_cli.commands.deps import deps
+from apm_cli.commands.experimental import experimental
 from apm_cli.commands.view import view as view_cmd
 from apm_cli.commands.init import init
 from apm_cli.commands.install import install
@@ -81,6 +82,7 @@ cli.add_command(run)
 cli.add_command(preview)
 cli.add_command(list_cmd, name="list")
 cli.add_command(config)
+cli.add_command(experimental)
 cli.add_command(runtime)
 cli.add_command(mcp)
 cli.add_command(policy)

{apm_cli-0.9.1 → apm_cli-0.9.3}/src/apm_cli/commands/_helpers.py

@@ -132,7 +132,7 @@ def _build_expected_install_paths(declared_deps, lockfile, apm_modules_dir: Path
             expected.add(str(install_path))
 
     if lockfile:
-        for dep in lockfile.get_all_dependencies():
+        for dep in lockfile.get_package_dependencies():
             if dep.depth is not None and dep.depth > 1:
                 dep_ref = dep.to_dependency_ref()
                 install_path = dep_ref.get_install_path(apm_modules_dir)
@@ -228,6 +228,25 @@ def print_version(ctx, param, value):
             f"{TITLE}Agent Package Manager (APM) CLI{RESET} version {version_str}"
         )
 
+    # Gated verbose-version output (experimental flag)
+    try:
+        from ..core.experimental import is_enabled
+
+        if is_enabled("verbose_version"):
+            import platform
+            import sys
+
+            python_ver = platform.python_version()
+            plat = f"{sys.platform}-{platform.machine()}"
+            install_path = str(Path(__file__).resolve().parent.parent)
+
+            _rich_echo(f"  {'Python:':<14}{python_ver}", color="dim")
+            _rich_echo(f"  {'Platform:':<14}{plat}", color="dim")
+            _rich_echo(f"  {'Install path:':<14}{install_path}", color="dim")
+    except Exception:
+        # Never let experimental flag logic break --version
+        pass
+
     ctx.exit()
 
 
@@ -462,6 +481,12 @@ def _create_minimal_apm_yml(config, plugin=False, target_path=None):
         "description": config["description"],
         "author": config["author"],
         "dependencies": {"apm": [], "mcp": []},
+        # Issue #887: scaffold with explicit consent for local content
+        # deployment so day-2 audit doesn't surprise the maintainer with
+        # an "includes not declared" advisory the moment they drop a
+        # primitive in .apm/.  Override with an explicit path list to
+        # gate what gets deployed.
+        "includes": "auto",
     }
 
     if plugin: