Merge origin/main into chore/prepare-v0.9.0

Resolve CHANGELOG conflict: keep [0.8.12] release section (which already
incorporates #616/#671/#681 from main's Unreleased), and add #766 entry
for the codex/opencode --target compile fix that landed via #769.

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

Author: danielmeppiel

.editorconfig

@@ -0,0 +1,25 @@
+# EditorConfig helps maintain consistent coding styles across different editors.
+# See https://editorconfig.org for details.
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+[*.{yml,yaml}]
+indent_size = 2
+
+[*.json]
+indent_size = 2
+
+[*.md]
+indent_size = 2
+# Trailing whitespace is significant in Markdown (line breaks), so leave it.
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

.github/workflows/daily-test-improver.md

@@ -246,7 +246,17 @@ Always do Task 7 (Update Monthly Activity Summary Issue) every run. In all comme
 
 Maintain a single open issue titled `[Test Improver] Monthly Activity {YYYY}-{MM}` as a rolling summary of all Test Improver activity for the current month.
 
-1. Search for an open `[Test Improver] Monthly Activity` issue with label `testing`. If it's for the current month, update it. If for a previous month, close it and create a new one. Read any maintainer comments - they may contain instructions or priorities; note them in memory.
+1. **Find the existing monthly issue (MANDATORY before any create)**:
+   - Determine the current month string as `YYYY-MM` (e.g. `2025-04`).
+   - Search for open issues using: `gh search issues --repo ${{ github.repository }} --state open --label testing "[Test Improver] Monthly Activity" --json number,title`
+   - From the results, collect all open issues whose title **contains** the current `YYYY-MM` string.
+   - **If exactly one matching issue for the current month exists: UPDATE it. Do NOT create a new issue.**
+   - **If multiple matching issues for the current month exist: treat the lowest-numbered issue as the canonical monthly issue, UPDATE it, and close every other current-month match as a duplicate of that canonical issue.**
+   - Before closing duplicate current-month issues, read any maintainer comments on each of them and preserve any instructions or priorities in memory, then consolidate any still-relevant details into the canonical issue update.
+   - If no matching issue exists for the current month but one exists for a previous month: close the old one, then create a new issue for the current month.
+   - If no matching issue exists at all: create a new issue for the current month.
+   - Read any maintainer comments on the canonical issue - they may contain instructions or priorities; note them in memory.
+   - **NEVER create a new issue if any open issue with the current month's `YYYY-MM` already exists in its title; update the canonical issue and close duplicates instead.**
 2. **Issue body format** - use **exactly** this structure:
 
    ```markdown

CHANGELOG.md

@@ -43,6 +43,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `_count_package_files` in `apm deps list` now reads the canonical `.apm/context/` (singular) directory; previously it scanned `.apm/contexts/` and always reported `0 context files` per package (#748)
 - `apm pack --format plugin` no longer emits duplicated `skills/skills/` nesting for bare-skill dependencies referenced through virtual paths like `skills/<name>` (#738)
 - Provide an ADO-specific authentication error message for `dev.azure.com` remotes so users get actionable guidance instead of a generic GitHub-flavored hint (#742)
+- Fix `apm compile --target codex` (and `opencode`, `minimal`) being a silent no-op; `AgentsCompiler.compile()` now routes these through the AGENTS.md compiler instead of returning an empty success result that left stale `AGENTS.md` files (#766)
 - Support `codeload.github.com`-style archive URLs in Artifactory archive URL generation, unblocking JFrog Artifactory proxies configured against `codeload.github.com` (#712)
 - `_parse_artifactory_base_url()` now reads `PROXY_REGISTRY_URL` first (with `ARTIFACTORY_BASE_URL` fallback + `DeprecationWarning`), and the virtual-subdirectory download path checks `dep_ref.is_artifactory()` before falling back to env-var detection, fixing lockfile reinstall failures when proxy config is only on the lockfile entry (#616)
 - Fall back to SSH URLs when validating git remotes for generic / self-hosted hosts so `apm install` no longer fails the pre-install validation step against private SSH-only servers (#584)

src/apm_cli/commands/compile/cli.py

@@ -380,23 +380,20 @@ def compile(
 
         # Handle distributed vs single-file compilation
         if config.strategy == "distributed" and not single_agents:
-            # Show target-aware message with detection reason
+            # Show target-aware message with detection reason. Use
+            # get_target_description() so any future target added to
+            # target_detection shows up here automatically.
             if detected_target == "minimal":
                 logger.progress(f"Compiling for AGENTS.md only ({detection_reason})")
                 logger.progress(
-                    " Create .github/ or .claude/ folder for full integration",
+                    " Create .github/, .claude/, .codex/, .opencode/ or .cursor/ folder for full integration",
                     symbol="light_bulb",
                 )
-            elif detected_target == "vscode" or detected_target == "agents":
-                logger.progress(
-                    f"Compiling for AGENTS.md (VSCode/Copilot) - {detection_reason}"
-                )
-            elif detected_target == "claude":
+            else:
+                description = get_target_description(detected_target)
                 logger.progress(
-                    f"Compiling for CLAUDE.md (Claude Code) - {detection_reason}"
+                    f"Compiling for {description} - {detection_reason}"
                 )
-            else:  # "all"
-                logger.progress(f"Compiling for AGENTS.md + CLAUDE.md - {detection_reason}")
 
             if dry_run:
                 logger.dry_run_notice(

src/apm_cli/compilation/agents_compiler.py

@@ -20,6 +20,15 @@
 )
 from .link_resolver import resolve_markdown_links, validate_link_targets
 from ..utils.paths import portable_relpath
+from ..core.target_detection import should_compile_agents_md, should_compile_claude_md
+
+
+# User-facing target aliases that map to the canonical "vscode" target.
+# Kept in sync with target_detection.detect_target().
+_VSCODE_TARGET_ALIASES = ("copilot", "agents")
+_KNOWN_TARGETS = (
+    "vscode", "claude", "cursor", "opencode", "codex", "all", "minimal",
+) + _VSCODE_TARGET_ALIASES
 
 
 @dataclass
@@ -199,17 +208,52 @@ def compile(self, config: CompilationConfig, primitives: Optional[PrimitiveColle
                         exclude_patterns=config.exclude,
                     )
 
-            # Route to targets based on config.target
+            # Route to targets based on config.target.
+            # Use target_detection helpers as the single source of truth so
+            # new targets (codex, opencode, cursor, minimal, ...) route
+            # correctly without touching this method again.
+            routing_target = (
+                "vscode" if config.target in _VSCODE_TARGET_ALIASES else config.target
+            )
+
+            if routing_target not in _KNOWN_TARGETS and config.target not in _KNOWN_TARGETS:
+                self.errors.append(
+                    f"Unknown compilation target: {config.target!r}. "
+                    f"Expected one of: {', '.join(sorted(set(_KNOWN_TARGETS)))}"
+                )
+                return CompilationResult(
+                    success=False,
+                    output_path="",
+                    content="",
+                    warnings=self.warnings.copy(),
+                    errors=self.errors.copy(),
+                    stats={},
+                )
+
             results: List[CompilationResult] = []
-            
-            # AGENTS.md target (vscode/agents)
-            if config.target in ("vscode", "agents", "all"):
+
+            if should_compile_agents_md(routing_target):
                 results.append(self._compile_agents_md(config, primitives))
-            
-            # CLAUDE.md target
-            if config.target in ("claude", "all"):
+
+            if should_compile_claude_md(routing_target):
                 results.append(self._compile_claude_md(config, primitives))
-            
+
+            # Defensive: should never happen for a known target, but guards
+            # against future target_detection drift silently producing no-ops.
+            if not results:
+                self.errors.append(
+                    f"Target {config.target!r} did not route to any compiler. "
+                    "This is an internal bug in target routing."
+                )
+                return CompilationResult(
+                    success=False,
+                    output_path="",
+                    content="",
+                    warnings=self.warnings.copy(),
+                    errors=self.errors.copy(),
+                    stats={},
+                )
+
             # Merge results from all targets
             return self._merge_results(results)
 

src/apm_cli/deps/github_downloader.py

@@ -412,20 +412,16 @@ def _should_use_artifactory_proxy(self, dep_ref: 'DependencyReference') -> bool:
         return is_github_hostname(host)
 
     def _parse_artifactory_base_url(self) -> Optional[tuple]:
-        """Parse ARTIFACTORY_BASE_URL into (host, prefix, scheme)."""
-        import urllib.parse as urlparse
-        base_url = os.environ.get('ARTIFACTORY_BASE_URL', '').strip().rstrip('/')
-        if not base_url:
-            return None
-        parsed = urlparse.urlparse(base_url)
-        if parsed.scheme not in ('https', 'http'):
-            _debug(f"ARTIFACTORY_BASE_URL has unsupported scheme: {parsed.scheme}")
-            return None
-        host = parsed.hostname
-        path = parsed.path.strip('/')
-        if not host or not path:
+        """Return ``(host, prefix, scheme)`` from the registry proxy config, or ``None``.
+
+        Delegates to :meth:`~apm_cli.deps.registry_proxy.RegistryConfig.from_env`
+        so that env-var precedence and deprecation warnings are handled in one place.
+        """
+        from .registry_proxy import RegistryConfig
+        cfg = RegistryConfig.from_env()
+        if cfg is None:
             return None
-        return (host, path, parsed.scheme)
+        return (cfg.host, cfg.prefix, cfg.scheme)
 
     def _resolve_dep_token(self, dep_ref: Optional[DependencyReference] = None) -> Optional[str]:
         """Resolve the per-dependency auth token via AuthResolver.
@@ -2125,8 +2121,13 @@ def download_package(
             elif dep_ref.is_virtual_collection():
                 return self.download_collection_package(dep_ref, target_path, progress_task_id, progress_obj)
             elif dep_ref.is_virtual_subdirectory():
-                # When PROXY_REGISTRY_ONLY is set, download full archive and extract subdir
-                art_proxy = self._parse_artifactory_base_url()
+                # Mode 1: explicit Artifactory FQDN from lockfile
+                if dep_ref.is_artifactory():
+                    proxy_info = (dep_ref.host, dep_ref.artifactory_prefix, "https")
+                    return self._download_subdirectory_from_artifactory(
+                        dep_ref, target_path, proxy_info, progress_task_id, progress_obj
+                    )
+                # Mode 2: transparent proxy via env var (art_proxy computed above)
                 if self._is_artifactory_only() and art_proxy:
                     return self._download_subdirectory_from_artifactory(
                         dep_ref, target_path, art_proxy, progress_task_id, progress_obj

tests/unit/compilation/test_compile_target_flag.py

@@ -166,14 +166,71 @@ def test_target_all_generates_both(self, temp_project, sample_primitives):
             dry_run=True,
             single_agents=True  # Use single-file for AGENTS.md
         )
-        
+
         compiler = AgentsCompiler(str(temp_project))
         result = compiler.compile(config, sample_primitives)
-        
+
         assert result.success
         # Output path should mention both targets
         assert "AGENTS.md" in result.output_path or "CLAUDE" in result.output_path
 
+    def test_target_codex_generates_agents_md(self, temp_project, sample_primitives):
+        """Regression for issue #766: --target codex must produce AGENTS.md, not a silent no-op."""
+        config = CompilationConfig(
+            target="codex",
+            dry_run=True,
+            single_agents=True,
+        )
+
+        compiler = AgentsCompiler(str(temp_project))
+        result = compiler.compile(config, sample_primitives)
+
+        assert result.success
+        assert result.output_path, "codex target must route to a compiler, not return empty"
+        assert "AGENTS.md" in result.output_path
+
+    def test_target_opencode_generates_agents_md(self, temp_project, sample_primitives):
+        """target='opencode' must route to AGENTS.md (same universal format as codex)."""
+        config = CompilationConfig(
+            target="opencode",
+            dry_run=True,
+            single_agents=True,
+        )
+
+        compiler = AgentsCompiler(str(temp_project))
+        result = compiler.compile(config, sample_primitives)
+
+        assert result.success
+        assert "AGENTS.md" in result.output_path
+
+    def test_target_minimal_generates_agents_md(self, temp_project, sample_primitives):
+        """target='minimal' must route to AGENTS.md-only."""
+        config = CompilationConfig(
+            target="minimal",
+            dry_run=True,
+            single_agents=True,
+        )
+
+        compiler = AgentsCompiler(str(temp_project))
+        result = compiler.compile(config, sample_primitives)
+
+        assert result.success
+        assert "AGENTS.md" in result.output_path
+
+    def test_unknown_target_returns_failure(self, temp_project, sample_primitives):
+        """Unknown target must fail explicitly instead of silently succeeding."""
+        config = CompilationConfig(
+            target="not-a-real-target",
+            dry_run=True,
+            single_agents=True,
+        )
+
+        compiler = AgentsCompiler(str(temp_project))
+        result = compiler.compile(config, sample_primitives)
+
+        assert result.success is False
+        assert any("Unknown compilation target" in e for e in result.errors)
+
 
 class TestMergeResults:
     """Tests for _merge_results() method."""