fix(hooks): scope merged-hook wipe to resolved targets, not all KNOWN_TARGETS (#2252)

* fix(hooks): scope merged-hook wipe to resolved targets, not all KNOWN_TARGETS

HookIntegrator.sync_integration() wiped package-owned merged-hook entries
across every supported harness (.claude/settings.json, .cursor/hooks.json,
.gemini/settings.json, .kiro/hooks/), while the uninstall/prune rebuild
paths that follow it only repopulate the project's currently-declared
targets: list. Narrowing targets: silently dropped a still-installed
sibling package's hooks (and its apm-hooks.json ownership sidecar) in the
now-undeclared target, with no rebuild to restore them.

HookIntegrator remains the single canonical owner of this decision:

- sync_integration() now decouples the file-deletion prefix guard (kept
  as the union of KNOWN_TARGETS + caller targets, never narrower than
  before -- a safety floor) from a new merge_source variable that scopes
  the merged-hook JSON cleanup loop to the caller-supplied targets,
  falling back to all KNOWN_TARGETS only when targets is None.
- reconcile_after_removal() now passes targets=targets into its internal
  sync_integration() call (previously omitted).
- uninstall/engine.py's _sync_integrations_after_uninstall() now passes
  targets=_resolved_targets (previously omitted).

Both apm uninstall and apm prune delegate to the same HookIntegrator
methods with the same resolved-target semantics the rebuild step uses --
no caller-specific cleanup logic.

Adds tests/integration/test_hook_wipe_target_scope_e2e.py: 8 hermetic
CLI-driven tests parametrized across both callers (uninstall, prune)
covering the narrowing repro with sibling + manual-entry preservation,
a negative twin (in-scope wipe still works), idempotency, zero-write
abort before the destructive wipe on resolve failure, and a mutation-
break proof that the scoped-targets behavior is load-bearing. Confirmed
RED (2/8 fail, reproducing #2250 for both callers) with the fix
reverted, GREEN (8/8) restored.

closes #2250

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 8f0f6bce-c30a-4694-934e-53ebec71d384

* chore: trigger spec-conformance re-run with waiver

apm-spec-waiver: restores the reconcile-and-preserve hook contract already documented in prune.md/manage-dependencies.md; corrects an implementation bug against an existing promise, no new normative behavior added

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 8f0f6bce-c30a-4694-934e-53ebec71d384

---------

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

Author: danielmeppiel

CHANGELOG.md

@@ -20,6 +20,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- `apm uninstall` and `apm prune` no longer wipe still-installed dependencies'
+  merged hook entries out of a harness (e.g. `.cursor/hooks.json`) that was
+  dropped from a project's `targets:` list -- the hook wipe is now scoped to
+  the same resolved target set the rebuild step repopulates, so a narrowed
+  `targets:` no longer silently deletes a sibling package's hooks (and its
+  `apm-hooks.json` sidecar) in the now-undeclared harness. (closes #2250)
 - `apm prune` no longer leaves stale, executable hook entries behind for a
   removed package: it now reconciles merged hook ownership when it removes
   an orphaned package, clearing entries it contributed to

src/apm_cli/commands/uninstall/engine.py

@@ -635,11 +635,18 @@ def _sync_integrations_after_uninstall(
                 )
                 counts["prompts"] += result.get("files_removed", 0)
 
-    # Hooks (multi-target sync_integration handles all targets)
+    # Hooks: managed-file removal always scans every KNOWN_TARGETS prefix
+    # (safe -- it only ever deletes files already tracked as this
+    # package's own deployed_files). The merged-hook JSON wipe, in
+    # contrast, is scoped to `_resolved_targets` -- the SAME set the
+    # Phase 2 rebuild loop below iterates -- so a harness dropped from
+    # this project's `targets:` list is never wiped for packages that
+    # remain declared and installed (#2250).
     result = _integrators["hooks"].sync_integration(
         apm_package,
         project_root,
         managed_files=_buckets["hooks"] if _buckets else None,
+        targets=_resolved_targets,
     )
     counts["hooks"] = result.get("files_removed", 0)
 

src/apm_cli/integration/hook_integrator.py

@@ -1877,27 +1877,32 @@ def sync_integration(
         """Remove APM-managed hook files.
 
         Uses *managed_files* (relative paths) to surgically remove only
-        APM-tracked files.  Falls back to legacy ``*-apm.json`` glob when
-        *managed_files* is ``None``.
-
-        **Never** calls ``shutil.rmtree``.
-
+        APM-tracked files; falls back to legacy ``*-apm.json`` glob when
+        *managed_files* is ``None``. **Never** calls ``shutil.rmtree``.
         Also cleans APM entries from merged-hook JSON files via the
         ``_apm_source`` marker.
+
+        ``targets`` (#2250) scopes ONLY the merged-hook JSON cleanup below,
+        NOT the ``managed_files`` prefix guard (union of ``KNOWN_TARGETS``
+        + ``targets``): that guard defends against deleting outside a
+        recognized ``hooks/`` dir, and narrowing it would strand real
+        files deployed under a since-dropped target.
         """
         from .targets import KNOWN_TARGETS
 
         stats: dict[str, int] = {"files_removed": 0, "errors": 0}
 
-        # Derive hook prefixes dynamically from targets
-        source = targets if targets is not None else list(KNOWN_TARGETS.values())
-        hook_prefixes = []
-        for t in source:
-            if t.supports("hooks"):
-                sm = t.primitives["hooks"]
-                effective_root = sm.deploy_root or t.root_dir
-                hook_prefixes.append(f"{effective_root}/hooks/")
-        hook_prefix_tuple = tuple(hook_prefixes)
+        # Prefix guard: union of KNOWN_TARGETS + caller `targets`, never
+        # narrower than the unscoped default -- see docstring above.
+        guard_targets = list(KNOWN_TARGETS.values())
+        if targets is not None:
+            guard_targets = guard_targets + list(targets)
+        hook_prefixes = [
+            f"{(t.primitives['hooks'].deploy_root or t.root_dir)}/hooks/"
+            for t in guard_targets
+            if t.supports("hooks")
+        ]
+        hook_prefix_tuple = tuple(dict.fromkeys(hook_prefixes))
 
         if managed_files is not None:
             # Manifest-based removal -- only remove tracked files
@@ -1929,8 +1934,10 @@ def sync_integration(
                     except Exception:
                         stats["errors"] += 1
 
-        # Clean APM entries from merged-hook JSON configs using external ownership.
-        for t in source:
+        # Clean APM entries from merged-hook JSON configs, scoped to
+        # `targets` when supplied -- matches the rebuild phase (#2250).
+        merge_source = targets if targets is not None else list(KNOWN_TARGETS.values())
+        for t in merge_source:
             config = _MERGE_HOOK_TARGETS.get(t.name)
             if config is not None:
                 json_path = project_root / t.root_dir / config.config_filename
@@ -1977,10 +1984,16 @@ def reconcile_after_removal(
         reconcile, consistent with prune's existing per-package
         error-tolerant semantics.
 
-        Known boundary (shared with uninstall, tracked in #2250):
-        rebuilds only direct dependencies from ``get_all_apm_dependencies()``
-        -- a transitive dependency's merged hooks are wiped by the clear
-        phase above but never re-integrated here.
+        Target scope (#2250): the merged-hook JSON wipe below is scoped to
+        the SAME resolved ``targets`` the rebuild loop uses, so a harness
+        dropped from ``targets:`` (but still holding stale merged-hook
+        entries) is never wiped for still-declared, still-installed
+        packages while the rebuild silently skips repopulating it.
+
+        Known boundary (shared with uninstall, #2250): rebuilds only
+        direct dependencies from ``get_all_apm_dependencies()`` -- a
+        transitive dependency's merged hooks are wiped above but never
+        re-integrated here.
         """
         from apm_cli.constants import APM_MODULES_DIR
         from apm_cli.models.apm_package import build_installed_package_info
@@ -2000,15 +2013,11 @@ def reconcile_after_removal(
         surviving_deps = list(apm_package.get_all_apm_dependencies())
 
         # Empty managed_files (not None) skips file-level deletion while
-        # still triggering the unconditional wipe of every _apm_source
-        # entry (and its ownership sidecar) across all KNOWN_TARGETS --
-        # see _clean_apm_entries_from_json. The narrower `targets` list
-        # resolved above is deliberately NOT passed here: doing so would
-        # make prune's wipe scope diverge from uninstall's identical
-        # call (both currently wipe all KNOWN_TARGETS by omitting
-        # targets=); that divergence is tracked as a shared-primitive
-        # fix in #2250, evaluated against all three callers together.
-        stats = self.sync_integration(apm_package, project_root, managed_files=set())
+        # still triggering the merged-hook JSON wipe, scoped to the same
+        # resolved `targets` the rebuild loop below uses (#2250).
+        stats = self.sync_integration(
+            apm_package, project_root, managed_files=set(), targets=targets
+        )
 
         for dep_ref in surviving_deps:
             pkg_info = build_installed_package_info(dep_ref, project_root / APM_MODULES_DIR)