apm-cli 0.8.3__tar.gz → 0.8.5__tar.gz

{apm_cli-0.8.3/src/apm_cli.egg-info → apm_cli-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.8.3
+Version: 0.8.5
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -52,6 +52,7 @@ Requires-Dist: GitPython>=3.1.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0.0; extra == "dev"
 Requires-Dist: black>=26.3.1; python_version >= "3.10" and extra == "dev"
 Requires-Dist: isort>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"

{apm_cli-0.8.3 → apm_cli-0.8.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.8.3"
+version = "0.8.5"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -41,6 +41,7 @@ dependencies = [
 dev = [
     "pytest>=7.0.0",
     "pytest-cov>=4.0.0",
+    "pytest-xdist>=3.0.0",
     "black>=26.3.1; python_version>='3.10'",
     "isort>=5.0.0",
     "mypy>=1.0.0",

{apm_cli-0.8.3 → apm_cli-0.8.5}/src/apm_cli/adapters/client/copilot.py

@@ -12,6 +12,7 @@ from .base import MCPClientAdapter
 from ...registry.client import SimpleRegistryClient
 from ...registry.integration import RegistryIntegration
 from ...core.docker_args import DockerArgsProcessor
+from ...core.token_manager import GitHubTokenManager
 from ...utils.github_host import is_github_hostname
 
 
@@ -199,8 +200,10 @@ class CopilotClientAdapter(MCPClientAdapter):
             is_github_server = self._is_github_server(server_name, remote.get("url", ""))
             
             if is_github_server:
-                # Check for GitHub Personal Access Token
-                github_token = os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
+                # Use centralized token manager (copilot chain: GITHUB_COPILOT_PAT → GITHUB_TOKEN → GITHUB_APM_PAT),
+                # falling back to GITHUB_PERSONAL_ACCESS_TOKEN for Copilot CLI compat.
+                _tm = GitHubTokenManager()
+                github_token = _tm.get_token_for_purpose('copilot') or os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")
                 if github_token:
                     config["headers"] = {
                         "Authorization": f"Bearer {github_token}"

{apm_cli-0.8.3 → apm_cli-0.8.5}/src/apm_cli/adapters/client/vscode.py

@@ -32,7 +32,7 @@ class VSCodeClientAdapter(MCPClientAdapter):
         self.registry_client = SimpleRegistryClient(registry_url)
         self.registry_integration = RegistryIntegration(registry_url)
     
-    def get_config_path(self):
+    def get_config_path(self, logger=None):
         """Get the path to the VSCode MCP configuration file in the repository.
         
         Returns:
@@ -50,11 +50,14 @@ class VSCodeClientAdapter(MCPClientAdapter):
             if not vscode_dir.exists():
                 vscode_dir.mkdir(parents=True, exist_ok=True)
         except Exception as e:
-            print(f"Warning: Could not create .vscode directory: {e}")
+            if logger:
+                logger.warning(f"Could not create .vscode directory: {e}")
+            else:
+                print(f"Warning: Could not create .vscode directory: {e}")
             
         return str(mcp_config_path)
     
-    def update_config(self, new_config):
+    def update_config(self, new_config, logger=None):
         """Update the VSCode MCP configuration with new values.
         
         Args:
@@ -63,7 +66,7 @@ class VSCodeClientAdapter(MCPClientAdapter):
         Returns:
             bool: True if successful, False otherwise.
         """
-        config_path = self.get_config_path()
+        config_path = self.get_config_path(logger=logger)
         
         try:
             # Write the updated config
@@ -72,16 +75,19 @@ class VSCodeClientAdapter(MCPClientAdapter):
                 
             return True
         except Exception as e:
-            print(f"Error updating VSCode MCP configuration: {e}")
+            if logger:
+                logger.error(f"Error updating VSCode MCP configuration: {e}")
+            else:
+                print(f"Error updating VSCode MCP configuration: {e}")
             return False
     
-    def get_current_config(self):
+    def get_current_config(self, logger=None):
         """Get the current VSCode MCP configuration.
         
         Returns:
             dict: Current VSCode MCP configuration from the local .vscode/mcp.json file.
         """
-        config_path = self.get_config_path()
+        config_path = self.get_config_path(logger=logger)
         
         try:
             try:
@@ -90,10 +96,13 @@ class VSCodeClientAdapter(MCPClientAdapter):
             except (FileNotFoundError, json.JSONDecodeError):
                 return {}
         except Exception as e:
-            print(f"Error reading VSCode MCP configuration: {e}")
+            if logger:
+                logger.error(f"Error reading VSCode MCP configuration: {e}")
+            else:
+                print(f"Error reading VSCode MCP configuration: {e}")
             return {}
     
-    def configure_mcp_server(self, server_url, server_name=None, enabled=True, env_overrides=None, server_info_cache=None, runtime_vars=None):
+    def configure_mcp_server(self, server_url, server_name=None, enabled=True, env_overrides=None, server_info_cache=None, runtime_vars=None, logger=None):
         """Configure an MCP server in VS Code mcp.json file.
         
         This method updates the .vscode/mcp.json file to add or update
@@ -105,6 +114,7 @@ class VSCodeClientAdapter(MCPClientAdapter):
             enabled (bool, optional): Whether to enable the server. Defaults to True.
             env_overrides (dict, optional): Environment variable overrides. Defaults to None.
             server_info_cache (dict, optional): Pre-fetched server info to avoid duplicate registry calls.
+            logger: Optional CommandLogger for structured output.
             
         Returns:
             bool: True if successful, False otherwise.
@@ -113,7 +123,10 @@ class VSCodeClientAdapter(MCPClientAdapter):
             ValueError: If server is not found in registry.
         """
         if not server_url:
-            print("Error: server_url cannot be empty")
+            if logger:
+                logger.error("server_url cannot be empty")
+            else:
+                print("Error: server_url cannot be empty")
             return False
             
         try:
@@ -133,14 +146,17 @@ class VSCodeClientAdapter(MCPClientAdapter):
             server_config, input_vars = self._format_server_config(server_info)
             
             if not server_config:
-                print(f"Unable to configure server: {server_url}")
+                if logger:
+                    logger.error(f"Unable to configure server: {server_url}")
+                else:
+                    print(f"Unable to configure server: {server_url}")
                 return False
             
             # Use provided server name or fallback to server_url
             config_key = server_name or server_url
             
             # Get current config
-            current_config = self.get_current_config()
+            current_config = self.get_current_config(logger=logger)
             
             # Ensure servers and inputs sections exist
             if "servers" not in current_config:
@@ -159,17 +175,23 @@ class VSCodeClientAdapter(MCPClientAdapter):
                     existing_input_ids.add(var.get("id"))
             
             # Update the configuration
-            result = self.update_config(current_config)
+            result = self.update_config(current_config, logger=logger)
             
             if result:
-                print(f"Successfully configured MCP server '{config_key}' for VS Code")
+                if logger:
+                    logger.verbose_detail(f"Configured MCP server '{config_key}' for VS Code")
+                else:
+                    print(f"Successfully configured MCP server '{config_key}' for VS Code")
             return result
             
         except ValueError:
             # Re-raise ValueError for registry errors
             raise
         except Exception as e:
-            print(f"Error configuring MCP server: {e}")
+            if logger:
+                logger.error(f"Error configuring MCP server: {e}")
+            else:
+                print(f"Error configuring MCP server: {e}")
             return False
 
     def _format_server_config(self, server_info):

apm_cli-0.8.5/src/apm_cli/bundle/lockfile_enrichment.py

@@ -0,0 +1,154 @@
+"""Lockfile enrichment for pack-time metadata."""
+
+from datetime import datetime, timezone
+from typing import Dict, List, Tuple
+
+from ..deps.lockfile import LockFile
+
+
+# Authoritative mapping of target names to deployed-file path prefixes.
+_TARGET_PREFIXES = {
+    "copilot": [".github/"],
+    "vscode": [".github/"],
+    "claude": [".claude/"],
+    "cursor": [".cursor/"],
+    "opencode": [".opencode/"],
+    "all": [".github/", ".claude/", ".cursor/", ".opencode/"],
+}
+
+# Cross-target path equivalences for skills/ and agents/ directories.
+# Only these two directory types are semantically identical across targets;
+# commands, instructions, hooks are target-specific and are NOT mapped.
+#
+# .github/ is the canonical interop prefix -- install always creates it, so
+# all non-github targets map FROM .github/.  The copilot target additionally
+# maps FROM .claude/ for the common case of Claude-first projects packing
+# for Copilot.  Cursor/opencode sources are niche; if someone publishes
+# skills exclusively under .cursor/, they must pack with --target cursor.
+_CROSS_TARGET_MAPS: Dict[str, Dict[str, str]] = {
+    "claude": {
+        ".github/skills/": ".claude/skills/",
+        ".github/agents/": ".claude/agents/",
+    },
+    "vscode": {
+        ".claude/skills/": ".github/skills/",
+        ".claude/agents/": ".github/agents/",
+    },
+    "copilot": {
+        ".claude/skills/": ".github/skills/",
+        ".claude/agents/": ".github/agents/",
+    },
+    "cursor": {
+        ".github/skills/": ".cursor/skills/",
+        ".github/agents/": ".cursor/agents/",
+    },
+    "opencode": {
+        ".github/skills/": ".opencode/skills/",
+        ".github/agents/": ".opencode/agents/",
+    },
+}
+
+
+def _filter_files_by_target(
+    deployed_files: List[str], target: str
+) -> Tuple[List[str], Dict[str, str]]:
+    """Filter deployed file paths by target prefix, with cross-target mapping.
+
+    When files are deployed under one target prefix (e.g. ``.github/skills/``)
+    but the pack target is different (e.g. ``claude``), skills and agents are
+    remapped to the equivalent target path.  Commands, instructions, and hooks
+    are NOT remapped -- they are target-specific.
+
+    Returns:
+        A tuple of ``(filtered_files, path_mappings)`` where *path_mappings*
+        maps ``bundle_path -> disk_path`` for any file that was cross-target
+        remapped.  Direct matches have no entry in the dict.
+    """
+    prefixes = _TARGET_PREFIXES.get(target, _TARGET_PREFIXES["all"])
+    direct = [f for f in deployed_files if any(f.startswith(p) for p in prefixes)]
+
+    path_mappings: Dict[str, str] = {}
+    cross_map = _CROSS_TARGET_MAPS.get(target, {})
+    if cross_map:
+        direct_set = set(direct)
+        for f in deployed_files:
+            if f in direct_set:
+                continue
+            for src_prefix, dst_prefix in cross_map.items():
+                if f.startswith(src_prefix):
+                    mapped = dst_prefix + f[len(src_prefix):]
+                    if mapped not in direct_set:
+                        direct.append(mapped)
+                        direct_set.add(mapped)
+                        path_mappings[mapped] = f
+                    break
+
+    return direct, path_mappings
+
+
+def enrich_lockfile_for_pack(
+    lockfile: LockFile,
+    fmt: str,
+    target: str,
+) -> str:
+    """Create an enriched copy of the lockfile YAML with a ``pack:`` section.
+
+    Filters each dependency's ``deployed_files`` to only include paths
+    matching the pack *target*, so the bundle lockfile is consistent with
+    the files actually shipped in the bundle.
+
+    Does NOT mutate the original *lockfile* object  -- serialises a copy and
+    prepends the pack metadata.
+
+    Args:
+        lockfile: The resolved lockfile to enrich.
+        fmt: Bundle format (``"apm"`` or ``"plugin"``).
+        target: Effective target used for packing (e.g. ``"copilot"``, ``"claude"``,
+            ``"all"``).  The internal alias ``"vscode"`` is also accepted.
+
+    Returns:
+        A YAML string with the ``pack:`` block followed by the original
+        lockfile content.
+    """
+    import yaml
+
+    # Build a filtered lockfile YAML: each dep's deployed_files is narrowed
+    # to only the paths matching the pack target (with cross-target mapping).
+    all_mappings: Dict[str, str] = {}
+    data = yaml.safe_load(lockfile.to_yaml())
+    if data and "dependencies" in data:
+        for dep in data["dependencies"]:
+            if "deployed_files" in dep:
+                filtered, mappings = _filter_files_by_target(
+                    dep["deployed_files"], target
+                )
+                dep["deployed_files"] = filtered
+                all_mappings.update(mappings)
+
+    # Build the pack: metadata section (after filtering so we know if mapping
+    # occurred).
+    pack_meta: Dict = {
+        "format": fmt,
+        "target": target,
+        "packed_at": datetime.now(timezone.utc).isoformat(),
+    }
+    if all_mappings:
+        # Record the source prefixes that were remapped so consumers know the
+        # bundle paths differ from the original lockfile.  Use the canonical
+        # prefix keys from _CROSS_TARGET_MAPS rather than reverse-engineering
+        # them from file paths.
+        cross_map = _CROSS_TARGET_MAPS.get(target, {})
+        used_src_prefixes = set()
+        for original in all_mappings.values():
+            for src_prefix in cross_map:
+                if original.startswith(src_prefix):
+                    used_src_prefixes.add(src_prefix)
+                    break
+        pack_meta["mapped_from"] = sorted(used_src_prefixes)
+
+    from ..utils.yaml_io import yaml_to_str
+
+    pack_section = yaml_to_str({"pack": pack_meta})
+
+    lockfile_yaml = yaml_to_str(data)
+    return pack_section + lockfile_yaml

{apm_cli-0.8.3 → apm_cli-0.8.5}/src/apm_cli/bundle/packer.py

@@ -5,23 +5,12 @@ import shutil
 import tarfile
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from ..deps.lockfile import LockFile, get_lockfile_path, migrate_lockfile_if_needed
 from ..models.apm_package import APMPackage
 from ..core.target_detection import detect_target
-from .lockfile_enrichment import enrich_lockfile_for_pack
-
-
-# Target prefix mapping ("copilot" and "vscode" both map to .github/)
-_TARGET_PREFIXES = {
-    "copilot": [".github/"],
-    "vscode": [".github/"],
-    "claude": [".claude/"],
-    "cursor": [".cursor/"],
-    "opencode": [".opencode/"],
-    "all": [".github/", ".claude/", ".cursor/", ".opencode/"],
-}
+from .lockfile_enrichment import enrich_lockfile_for_pack, _filter_files_by_target
 
 
 @dataclass
@@ -31,12 +20,8 @@ class PackResult:
     bundle_path: Path
     files: List[str] = field(default_factory=list)
     lockfile_enriched: bool = False
-
-
-def _filter_files_by_target(deployed_files: List[str], target: str) -> List[str]:
-    """Filter deployed file paths by target prefix."""
-    prefixes = _TARGET_PREFIXES.get(target, _TARGET_PREFIXES["all"])
-    return [f for f in deployed_files if any(f.startswith(p) for p in prefixes)]
+    mapped_count: int = 0
+    path_mappings: Dict[str, str] = field(default_factory=dict)
 
 
 def pack_bundle(
@@ -47,6 +32,7 @@ def pack_bundle(
     archive: bool = False,
     dry_run: bool = False,
     force: bool = False,
+    logger=None,
 ) -> PackResult:
     """Create a self-contained bundle from installed APM dependencies.
 
@@ -54,7 +40,7 @@ def pack_bundle(
         project_root: Root of the project containing ``apm.lock.yaml`` and ``apm.yml``.
         output_dir: Directory where the bundle will be created.
         fmt: Bundle format  -- ``"apm"`` (default) or ``"plugin"``.
-        target: Target filter  -- ``"vscode"``, ``"claude"``, ``"all"``, or *None*
+        target: Target filter  -- ``"copilot"``, ``"claude"``, ``"all"``, or *None*
             (auto-detect from apm.yml / project structure).
         archive: If *True*, produce a ``.tar.gz`` and remove the directory.
         dry_run: If *True*, resolve the file list but write nothing to disk.
@@ -81,6 +67,7 @@ def pack_bundle(
             archive=archive,
             dry_run=dry_run,
             force=force,
+            logger=logger,
         )
 
     lockfile_path = get_lockfile_path(project_root)
@@ -129,7 +116,7 @@ def pack_bundle(
     for dep in lockfile.get_all_dependencies():
         all_deployed.extend(dep.deployed_files)
 
-    filtered_files = _filter_files_by_target(all_deployed, effective_target)
+    filtered_files, path_mappings = _filter_files_by_target(all_deployed, effective_target)
     # Deduplicate while preserving order
     seen = set()
     unique_files: List[str] = []
@@ -148,14 +135,16 @@ def pack_bundle(
             raise ValueError(
                 f"Refusing to pack unsafe path from lockfile: {rel_path!r}"
             )
-        abs_path = project_root / rel_path
+        # For cross-target mapped files, verify the original (on-disk) path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        abs_path = project_root / disk_path
         if not abs_path.resolve().is_relative_to(project_root_resolved):
             raise ValueError(
-                f"Refusing to pack path that escapes project root: {rel_path!r}"
+                f"Refusing to pack path that escapes project root: {disk_path!r}"
             )
         # deployed_files may reference directories (ending with /)
         if not abs_path.exists():
-            missing.append(rel_path)
+            missing.append(disk_path)
     if missing:
         raise ValueError(
             f"The following deployed files are missing on disk  -- "
@@ -170,6 +159,8 @@ def pack_bundle(
             bundle_path=bundle_dir,
             files=unique_files,
             lockfile_enriched=True,
+            mapped_count=len(path_mappings),
+            path_mappings=path_mappings,
         )
 
     # 5b. Scan files for hidden characters before bundling.
@@ -183,7 +174,8 @@ def pack_bundle(
 
     _scan_findings_total = 0
     for rel_path in unique_files:
-        src = project_root / rel_path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        src = project_root / disk_path
         if src.is_symlink():
             continue
         if src.is_dir():
@@ -196,21 +188,33 @@ def pack_bundle(
             )
             _scan_findings_total += len(verdict.all_findings)
     if _scan_findings_total:
-        _rich_warning(
+        _warn_msg = (
             f"Bundle contains {_scan_findings_total} hidden character(s) across source files "
             f"— run 'apm audit' to inspect before publishing"
         )
+        if logger:
+            logger.warning(_warn_msg)
+        else:
+            _rich_warning(_warn_msg)
 
     # 6. Build output directory
     bundle_dir = output_dir / f"{pkg_name}-{pkg_version}"
     bundle_dir.mkdir(parents=True, exist_ok=True)
+    bundle_dir_resolved = bundle_dir.resolve()
 
     # 7. Copy files preserving directory structure
     for rel_path in unique_files:
-        src = project_root / rel_path
+        # For cross-target mapped files, read from the original disk path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        src = project_root / disk_path
         if src.is_symlink():
             continue  # Never bundle symlinks
         dest = bundle_dir / rel_path
+        # Defense-in-depth: verify mapped destination stays inside the bundle
+        if not dest.resolve().is_relative_to(bundle_dir_resolved):
+            raise ValueError(
+                f"Refusing to write outside bundle directory: {rel_path!r}"
+            )
         if src.is_dir():
             from ..security.gate import ignore_symlinks
             shutil.copytree(src, dest, dirs_exist_ok=True, ignore=ignore_symlinks)
@@ -226,6 +230,8 @@ def pack_bundle(
         bundle_path=bundle_dir,
         files=unique_files,
         lockfile_enriched=True,
+        mapped_count=len(path_mappings),
+        path_mappings=path_mappings,
     )
 
     # 10. Archive if requested

{apm_cli-0.8.3 → apm_cli-0.8.5}/src/apm_cli/bundle/plugin_exporter.py

@@ -285,7 +285,8 @@ def _get_dev_dependency_urls(apm_yml_path: Path) -> Set[Tuple[str, str]]:
     ``github/awesome-copilot``).
     """
     try:
-        data = yaml.safe_load(apm_yml_path.read_text(encoding="utf-8"))
+        from ..utils.yaml_io import load_yaml
+        data = load_yaml(apm_yml_path)
     except (yaml.YAMLError, OSError, ValueError):
         return set()
     if not isinstance(data, dict):
@@ -319,7 +320,7 @@ def _get_dev_dependency_urls(apm_yml_path: Path) -> Set[Tuple[str, str]]:
 
 
 def _find_or_synthesize_plugin_json(
-    project_root: Path, apm_yml_path: Path
+    project_root: Path, apm_yml_path: Path, logger=None,
 ) -> dict:
     """Locate an existing ``plugin.json`` or synthesise one from ``apm.yml``."""
     from ..deps.plugin_parser import synthesize_plugin_json_from_apm_yml
@@ -330,16 +331,24 @@ def _find_or_synthesize_plugin_json(
         try:
             return json.loads(plugin_json_path.read_text(encoding="utf-8"))
         except (json.JSONDecodeError, OSError) as exc:
-            _rich_warning(
+            _warn_msg = (
                 f"Found plugin.json at {plugin_json_path} but could not parse it: {exc}. "
                 "Falling back to synthesis from apm.yml."
             )
+            if logger:
+                logger.warning(_warn_msg)
+            else:
+                _rich_warning(_warn_msg)
 
     else:
-        _rich_warning(
+        _warn_msg = (
             "No plugin.json found. Synthesizing from apm.yml. "
             "Consider running 'apm init --plugin'."
         )
+        if logger:
+            logger.warning(_warn_msg)
+        else:
+            _rich_warning(_warn_msg)
     return synthesize_plugin_json_from_apm_yml(apm_yml_path)
 
 
@@ -400,6 +409,7 @@ def export_plugin_bundle(
     archive: bool = False,
     dry_run: bool = False,
     force: bool = False,
+    logger=None,
 ) -> PackResult:
     """Export the project as a plugin-native directory.
 
@@ -439,7 +449,7 @@ def export_plugin_bundle(
             )
 
     # 3. Find or synthesize plugin.json
-    plugin_json = _find_or_synthesize_plugin_json(project_root, apm_yml_path)
+    plugin_json = _find_or_synthesize_plugin_json(project_root, apm_yml_path, logger=logger)
 
     # 4. devDependencies filtering
     dev_dep_urls = _get_dev_dependency_urls(apm_yml_path)
@@ -510,7 +520,10 @@ def export_plugin_bundle(
 
     # 7. Emit collision warnings
     for msg in collisions:
-        _rich_warning(msg)
+        if logger:
+            logger.warning(msg)
+        else:
+            _rich_warning(msg)
 
     # 8. Build output file list (sorted for determinism)
     output_files = sorted(file_map.keys())
@@ -548,10 +561,14 @@ def export_plugin_bundle(
             verdict = SecurityGate.scan_text(text, str(src), policy=WARN_POLICY)
             scan_findings_total += len(verdict.all_findings)
     if scan_findings_total:
-        _rich_warning(
+        _warn_msg = (
             f"Bundle contains {scan_findings_total} hidden character(s) across "
             f"source files — run 'apm audit' to inspect before publishing"
         )
+        if logger:
+            logger.warning(_warn_msg)
+        else:
+            _rich_warning(_warn_msg)
 
     # 11. Write files to output directory (clean slate to prevent symlink attacks)
     if bundle_dir.exists():

{apm_cli-0.8.3 → apm_cli-0.8.5}/src/apm_cli/bundle/unpacker.py

@@ -22,6 +22,7 @@ class UnpackResult:
     skipped_count: int = 0
     security_warnings: int = 0
     security_critical: int = 0
+    pack_meta: Dict = field(default_factory=dict)
 
 
 def unpack_bundle(
@@ -98,6 +99,18 @@ def unpack_bundle(
             legacy_lockfile_path = source_dir / LEGACY_LOCKFILE_NAME
             if legacy_lockfile_path.exists():
                 lockfile_path = legacy_lockfile_path
+
+        # Extract pack: metadata (written by apm pack) before structured parse
+        pack_meta: Dict = {}
+        try:
+            import yaml
+            raw = yaml.safe_load(lockfile_path.read_text(encoding="utf-8"))
+            if isinstance(raw, dict):
+                val = raw.get("pack", {})
+                pack_meta = val if isinstance(val, dict) else {}
+        except Exception:
+            pass  # non-critical -- proceed without metadata
+
         lockfile = LockFile.read(lockfile_path)
         if lockfile is None:
             if not lockfile_path.exists():
@@ -176,6 +189,7 @@ def unpack_bundle(
                 dependency_files=dep_file_map,
                 security_warnings=security_warnings,
                 security_critical=security_critical,
+                pack_meta=pack_meta,
             )
 
         # 4. Copy target files to output_dir (additive, no deletes)
@@ -219,6 +233,7 @@ def unpack_bundle(
             skipped_count=skipped,
             security_warnings=security_warnings,
             security_critical=security_critical,
+            pack_meta=pack_meta,
         )
     finally:
         # Clean up temp dir if we created one