@softspark/ai-toolkit 4.16.1 → 4.18.0

package/scripts/output_filter_retirement.py

@@ -0,0 +1,395 @@
+"""Retirement cleanup for the v4.16.x native tool-output filter.
+
+v4.16.0 and v4.16.1 installed a PostToolUse filter that wrote files outside the
+npm package: a hook script, a global policy, per-project policy files, and
+private recovery trees that can hold captured command output. v4.17.0 removed
+the feature, so those files are orphaned on every machine that ran the old
+releases. ``install``/``update`` and ``uninstall`` both reclaim them here.
+
+The implementation is deliberately self-contained. The package that wrote these
+files (``scripts/tool_output_filter/``) no longer exists in the repository, so
+the ownership rules it enforced are re-stated as literal constants instead of
+being imported. Nothing is removed without matching one of those rules, and no
+path is ever opened through a symlink.
+"""
+from __future__ import annotations
+
+import json
+import os
+import stat
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Ownership constants copied from the removed v4.16.x runtime
+# ---------------------------------------------------------------------------
+
+HOOK_SCRIPT_NAME = "filter-tool-output.sh"
+HOOK_SCRIPT_MARKER = b"# Claude PostToolUse adapter for the native tool-output filter."
+
+GLOBAL_POLICY_NAME = "output-filter-policy.json"
+
+PROJECT_POLICY_NAME = "ai-toolkit-output-filter.json"
+PROJECT_OWNER_NAME = ".ai-toolkit-output-filter.owner"
+PROJECT_OWNER_MARKER = b"ai-toolkit-output-filter-policy-v1\n"
+
+RUNTIME_SCRIPTS: tuple[tuple[str, bytes], ...] = (
+    (
+        "output_filter_hook.py",
+        b'"""Lean process entry point for the Claude output-filter hook."""',
+    ),
+    (
+        "output_filter_cli.py",
+        b'"""Manual and hook entry points for native tool-output filtering."""',
+    ),
+)
+
+RUNTIME_PACKAGE_NAME = "tool_output_filter"
+RUNTIME_PACKAGE_MARKER = b'"""Dependency-free post-execution tool-output filtering."""'
+_PACKAGE_MODULES: tuple[str, ...] = (
+    "__init__.py",
+    "contracts.py",
+    "engine.py",
+    "hook_runtime.py",
+    "input.py",
+    "invariants.py",
+    "policy.py",
+    "recovery.py",
+    "telemetry.py",
+)
+_PACKAGE_SUBPACKAGES: dict[str, tuple[str, ...]] = {
+    "profiles": ("__init__.py", "repeat_lines.py", "tap_success.py"),
+}
+
+_RECOVERY_DIRECTORY_NAME = "output-filter"
+_RECOVERY_TOKEN_LENGTH = 32
+_RECOVERY_CIRCUIT_STATE_NAME = ".circuit-state.json"
+_RECOVERY_TELEMETRY_NAME = ".telemetry.jsonl"
+_RECOVERY_PENDING_PREFIX = ".pending-"
+_RECOVERY_DIRECTORY_FLAGS = (
+    os.O_RDONLY
+    | getattr(os, "O_CLOEXEC", 0)
+    | getattr(os, "O_DIRECTORY", 0)
+    | getattr(os, "O_NOFOLLOW", 0)
+)
+
+
+# ---------------------------------------------------------------------------
+# Recovery trees (sessions/<repo-key>/output-filter/<session>/)
+# ---------------------------------------------------------------------------
+
+def _is_recovery_token(name: str) -> bool:
+    return (
+        len(name) == _RECOVERY_TOKEN_LENGTH
+        and all(character in "0123456789abcdef" for character in name)
+    )
+
+
+def _is_recovery_artifact_name(name: str) -> bool:
+    """Match only the artifact names the removed filter could have written."""
+    if name in {_RECOVERY_CIRCUIT_STATE_NAME, _RECOVERY_TELEMETRY_NAME}:
+        return True
+    if name.endswith(".json") and _is_recovery_token(name[:-len(".json")]):
+        return True
+    return name.startswith(_RECOVERY_PENDING_PREFIX) and _is_recovery_token(
+        name[len(_RECOVERY_PENDING_PREFIX):]
+    )
+
+
+def _assert_private_recovery_directory(directory_fd: int, label: str) -> None:
+    metadata = os.fstat(directory_fd)
+    if not stat.S_ISDIR(metadata.st_mode):
+        raise RuntimeError(f"{label} is not a directory")
+    if stat.S_IMODE(metadata.st_mode) & 0o077:
+        raise RuntimeError(f"{label} is not private")
+    if metadata.st_uid != os.getuid():
+        raise RuntimeError(f"{label} is not owned by this user")
+
+
+def _open_recovery_directory(parent_fd: int, name: str, label: str) -> int:
+    metadata = os.stat(name, dir_fd=parent_fd, follow_symlinks=False)
+    if not stat.S_ISDIR(metadata.st_mode):
+        raise RuntimeError(f"{label} is not a directory")
+    return os.open(name, _RECOVERY_DIRECTORY_FLAGS, dir_fd=parent_fd)
+
+
+def _scan_recovery_session(session_fd: int) -> tuple[str, ...]:
+    """Return validated artifact names, refusing anything not owner-private."""
+    _assert_private_recovery_directory(session_fd, "owned recovery session")
+    artifacts = tuple(
+        name for name in os.listdir(session_fd) if _is_recovery_artifact_name(name)
+    )
+    for artifact_name in artifacts:
+        metadata = os.stat(artifact_name, dir_fd=session_fd, follow_symlinks=False)
+        if not stat.S_ISREG(metadata.st_mode):
+            raise RuntimeError("owned recovery artifact is not regular")
+        if stat.S_IMODE(metadata.st_mode) != 0o600:
+            raise RuntimeError("owned recovery artifact is not private")
+    return artifacts
+
+
+def _walk_recovery_tree(sessions_root: Path, *, delete: bool) -> int:
+    """Validate every repo tree, optionally unlinking the owned artifacts.
+
+    Counting validates the whole tree before ``delete`` ever runs, so an unsafe
+    symlink anywhere aborts the cleanup before the first unlink.
+    """
+    try:
+        root_fd = os.open(sessions_root, _RECOVERY_DIRECTORY_FLAGS)
+    except FileNotFoundError:
+        return 0
+    except OSError as error:
+        raise RuntimeError(f"recovery base is unavailable: {error}") from error
+    total = 0
+    try:
+        for repo_name in sorted(os.listdir(root_fd)):
+            try:
+                metadata = os.stat(repo_name, dir_fd=root_fd, follow_symlinks=False)
+            except FileNotFoundError:
+                continue
+            if not stat.S_ISDIR(metadata.st_mode):
+                continue
+            repo_fd = os.open(repo_name, _RECOVERY_DIRECTORY_FLAGS, dir_fd=root_fd)
+            try:
+                total += _walk_recovery_repo(repo_fd, delete=delete)
+            finally:
+                os.close(repo_fd)
+    finally:
+        os.close(root_fd)
+    return total
+
+
+def _walk_recovery_repo(repo_fd: int, *, delete: bool) -> int:
+    try:
+        output_fd = _open_recovery_directory(
+            repo_fd,
+            _RECOVERY_DIRECTORY_NAME,
+            "owned output-filter directory",
+        )
+    except FileNotFoundError:
+        return 0
+    total = 0
+    try:
+        _assert_private_recovery_directory(
+            output_fd,
+            "owned output-filter directory",
+        )
+        for session_name in sorted(os.listdir(output_fd)):
+            if not _is_recovery_token(session_name):
+                continue
+            session_fd = _open_recovery_directory(
+                output_fd,
+                session_name,
+                "owned recovery session",
+            )
+            try:
+                artifacts = _scan_recovery_session(session_fd)
+                total += len(artifacts)
+                if not delete:
+                    continue
+                for artifact_name in artifacts:
+                    os.unlink(artifact_name, dir_fd=session_fd)
+                if artifacts:
+                    os.fsync(session_fd)
+            finally:
+                os.close(session_fd)
+            if delete:
+                # Foreign content keeps the directory: rmdir fails, we move on.
+                try:
+                    os.rmdir(session_name, dir_fd=output_fd)
+                except OSError:
+                    pass
+    finally:
+        os.close(output_fd)
+    if delete:
+        try:
+            os.rmdir(_RECOVERY_DIRECTORY_NAME, dir_fd=repo_fd)
+        except OSError:
+            pass
+    return total
+
+
+def count_owned_recovery_artifacts(sessions_root: Path) -> int:
+    """Count validated leftover filter artifacts without mutating the tree."""
+    return _walk_recovery_tree(sessions_root, delete=False)
+
+
+def clean_owned_recovery_tree(sessions_root: Path) -> int:
+    """Delete validated leftover filter artifacts below all repo sessions."""
+    return _walk_recovery_tree(sessions_root, delete=True)
+
+
+# ---------------------------------------------------------------------------
+# Per-project policy pair (<project>/.claude/)
+# ---------------------------------------------------------------------------
+
+def managed_project_policy(claude_dir: Path) -> list[Path]:
+    """Return the managed per-project policy pair, or [] when unmanaged.
+
+    The owner marker is the ownership test: without it the policy file was
+    hand-written by the user and stays put.
+    """
+    if claude_dir.is_symlink():
+        return []
+    policy = claude_dir / PROJECT_POLICY_NAME
+    owner = claude_dir / PROJECT_OWNER_NAME
+    if owner.is_symlink() or not owner.is_file():
+        return []
+    try:
+        if owner.read_bytes() != PROJECT_OWNER_MARKER:
+            return []
+    except OSError:
+        return []
+    managed = [owner]
+    if not policy.is_symlink() and policy.is_file():
+        managed.insert(0, policy)
+    return managed
+
+
+# ---------------------------------------------------------------------------
+# Global artifacts (~/.softspark/ai-toolkit/)
+# ---------------------------------------------------------------------------
+
+def _owned_regular_file(path: Path, marker: bytes | None) -> bool:
+    """True only for a real file that still carries its shipped marker."""
+    if path.is_symlink() or not path.is_file():
+        return False
+    if marker is None:
+        return True
+    try:
+        return marker in path.read_bytes()
+    except OSError:
+        return False
+
+
+def _owned_global_policy(path: Path) -> bool:
+    """True for the seeded global policy, including a user-edited mode."""
+    if path.is_symlink() or not path.is_file():
+        return False
+    try:
+        document = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return False
+    return isinstance(document, dict) and "mode" in document
+
+
+def _owned_package_root(package_root: Path) -> bool:
+    if package_root.is_symlink() or not package_root.is_dir():
+        return False
+    return _owned_regular_file(package_root / "__init__.py", RUNTIME_PACKAGE_MARKER)
+
+
+def _remove_package_members(directory: Path, modules: tuple[str, ...]) -> None:
+    """Unlink known modules plus their bytecode, leaving anything else alone."""
+    stems = {name[: -len(".py")] for name in modules}
+    for name in modules:
+        member = directory / name
+        if not member.is_symlink() and member.is_file():
+            member.unlink()
+    cache = directory / "__pycache__"
+    if not cache.is_symlink() and cache.is_dir():
+        for compiled in sorted(cache.iterdir()):
+            if compiled.is_symlink() or not compiled.is_file():
+                continue
+            if not compiled.name.endswith(".pyc") or ".cpython-" not in compiled.name:
+                continue
+            if compiled.name.split(".", 1)[0] in stems:
+                compiled.unlink()
+        _rmdir_if_empty(cache)
+
+
+def _rmdir_if_empty(directory: Path) -> None:
+    try:
+        directory.rmdir()
+    except OSError:
+        # Foreign content still lives here: leave the whole directory in place.
+        pass
+
+
+def _global_artifact_paths(toolkit_data_dir: Path) -> list[tuple[Path, str]]:
+    """Return every verified global leftover as (path, human label)."""
+    hooks_dir = toolkit_data_dir / "hooks"
+    scripts_dir = toolkit_data_dir / "scripts"
+    found: list[tuple[Path, str]] = []
+
+    if not hooks_dir.is_symlink() and hooks_dir.is_dir():
+        hook_script = hooks_dir / HOOK_SCRIPT_NAME
+        if _owned_regular_file(hook_script, HOOK_SCRIPT_MARKER):
+            found.append((hook_script, f"hooks/{HOOK_SCRIPT_NAME}"))
+        global_policy = hooks_dir / GLOBAL_POLICY_NAME
+        if _owned_global_policy(global_policy):
+            found.append((global_policy, f"hooks/{GLOBAL_POLICY_NAME}"))
+
+    if not scripts_dir.is_symlink() and scripts_dir.is_dir():
+        for name, marker in RUNTIME_SCRIPTS:
+            runtime_script = scripts_dir / name
+            if _owned_regular_file(runtime_script, marker):
+                found.append((runtime_script, f"scripts/{name}"))
+        package_root = scripts_dir / RUNTIME_PACKAGE_NAME
+        if _owned_package_root(package_root):
+            found.append((package_root, f"scripts/{RUNTIME_PACKAGE_NAME}/"))
+
+    return found
+
+
+def _recovery_label(artifacts: int) -> str:
+    noun = "file" if artifacts == 1 else "files"
+    return f"sessions/*/{_RECOVERY_DIRECTORY_NAME}/ ({artifacts} {noun})"
+
+
+def find_global_artifacts(toolkit_data_dir: Path) -> list[str]:
+    """List labels for leftovers a cleanup run would remove. Never mutates."""
+    labels = [label for _, label in _global_artifact_paths(toolkit_data_dir)]
+    try:
+        artifacts = count_owned_recovery_artifacts(toolkit_data_dir / "sessions")
+    except (OSError, RuntimeError):
+        artifacts = 0
+    if artifacts:
+        labels.append(_recovery_label(artifacts))
+    return labels
+
+
+def cleanup_global_artifacts(toolkit_data_dir: Path) -> tuple[list[str], list[str]]:
+    """Remove verified leftovers under the toolkit data directory.
+
+    Returns ``(removed_labels, warnings)``. Both are empty on a clean machine,
+    which keeps the caller silent when there is nothing to retire.
+    """
+    removed: list[str] = []
+    warnings: list[str] = []
+
+    for path, label in _global_artifact_paths(toolkit_data_dir):
+        try:
+            if path.is_dir():
+                _remove_package_members(path, _PACKAGE_MODULES)
+                for sub_name, sub_modules in _PACKAGE_SUBPACKAGES.items():
+                    sub_directory = path / sub_name
+                    if sub_directory.is_symlink() or not sub_directory.is_dir():
+                        continue
+                    _remove_package_members(sub_directory, sub_modules)
+                    _rmdir_if_empty(sub_directory)
+                _rmdir_if_empty(path)
+                if path.exists():
+                    warnings.append(
+                        f"removed {label} modules but kept the directory "
+                        "(unrecognized files inside)"
+                    )
+                    continue
+            else:
+                path.unlink()
+        except OSError as error:
+            warnings.append(f"kept {label} ({error})")
+            continue
+        removed.append(label)
+
+    sessions_root = toolkit_data_dir / "sessions"
+    try:
+        artifacts = clean_owned_recovery_tree(sessions_root)
+    except (OSError, RuntimeError) as error:
+        warnings.append(
+            f"kept sessions/*/{_RECOVERY_DIRECTORY_NAME}/ recovery data ({error})"
+        )
+    else:
+        if artifacts:
+            removed.append(_recovery_label(artifacts))
+
+    return removed, warnings

package/scripts/plugin.py

@@ -76,8 +76,8 @@ CODEX_PLUGIN_ASSET_MARKER = "# ai-toolkit-managed: codex-plugin-hook"
 def _empty_state() -> dict:
     return {
         "targets": {
-            "claude": {"installed": []},
-            "codex": {"installed": []},
+            "claude": {"installed": [], "versions": {}},
+            "codex": {"installed": [], "versions": {}},
         }
     }
 
@@ -103,6 +103,13 @@ def load_state() -> dict:
                     installed = targets.get(editor, {}).get("installed", [])
                     if isinstance(installed, list):
                         state["targets"][editor]["installed"] = sorted(set(installed))
+                    # Absent in state written before versions were tracked, so
+                    # every pack looks stale once and is updated exactly once.
+                    versions = targets.get(editor, {}).get("versions", {})
+                    if isinstance(versions, dict):
+                        state["targets"][editor]["versions"] = {
+                            k: v for k, v in versions.items() if isinstance(v, str)
+                        }
     return state
 
 
@@ -118,6 +125,18 @@ def _installed_for(state: dict, editor: str) -> list[str]:
     return list(state.get("targets", {}).get(editor, {}).get("installed", []))
 
 
+def _installed_version(state: dict, editor: str, name: str) -> str:
+    return state.get("targets", {}).get(editor, {}).get("versions", {}).get(name, "")
+
+
+def _record_version(state: dict, editor: str, name: str, version: str) -> None:
+    state.setdefault("targets", {}).setdefault(editor, {}).setdefault("versions", {})[name] = version
+
+
+def _forget_version(state: dict, editor: str, name: str) -> None:
+    state.get("targets", {}).get(editor, {}).get("versions", {}).pop(name, None)
+
+
 def _set_installed(state: dict, editor: str, names: list[str]) -> None:
     state.setdefault("targets", {}).setdefault(editor, {})
     state["targets"][editor]["installed"] = sorted(set(names))
@@ -264,6 +283,11 @@ def _copy_plugin_scripts(name: str, pack_dir: Path, installed_items: list[str])
     for script_file in sorted(plugin_scripts_dir.iterdir()):
         if script_file.name.startswith("__"):
             continue
+        # copy2 on a directory raises IsADirectoryError and aborts the install
+        # halfway with nothing rolled back, so a pack that ships scripts/bin/
+        # or a stray __pycache__ would break it.
+        if not script_file.is_file():
+            continue
         dest = scripts_dest / script_file.name
         shutil.copy2(script_file, dest)
         if script_file.suffix in (".py", ".sh"):
@@ -271,8 +295,13 @@ def _copy_plugin_scripts(name: str, pack_dir: Path, installed_items: list[str])
         print(f"    Copied script: {script_file.name}")
         installed_items.append(f"script:{dest}")
 
-    init_script = plugin_scripts_dir / "init_db.py"
-    if init_script.is_file():
+    # `init.py` is the generic name; `init_db.py` predates it and is what
+    # memory-pack ships. A pack whose init script is named anything else is
+    # silently never run, and the install still reports success.
+    for candidate in ("init.py", "init_db.py"):
+        init_script = plugin_scripts_dir / candidate
+        if not init_script.is_file():
+            continue
         result = subprocess.run(
             ["python3", str(init_script)],
             capture_output=True,
@@ -280,8 +309,10 @@ def _copy_plugin_scripts(name: str, pack_dir: Path, installed_items: list[str])
         )
         if result.returncode == 0 and result.stdout.strip():
             print(f"    Init: {result.stdout.strip()}")
-        elif result.returncode != 0 and result.stderr.strip():
-            print(f"    WARN init failed: {result.stderr.strip()}")
+        elif result.returncode != 0:
+            detail = result.stderr.strip() or result.stdout.strip() or "no output"
+            print(f"    WARN init failed: {detail}")
+        break
 
 
 def _copy_plugin_hook_scripts(name: str, hook_specs: list[dict], installed_items: list[str]) -> None:
@@ -908,6 +939,10 @@ def install_pack(name: str, editor: str) -> bool:
     if name not in installed:
         installed.append(name)
     _set_installed(state, editor, installed)
+    # Recorded so `update --all` can skip a pack whose manifest has not moved.
+    # Without it, update removes and reinstalls every pack every time, which for
+    # a pack that downloads a binary means refetching it on every core update.
+    _record_version(state, editor, name, str(pack.get("version", "")))
     save_state(state)
     return True
 
@@ -941,17 +976,40 @@ def remove_pack(name: str, editor: str) -> bool:
 
     installed = [p for p in installed if p != name]
     _set_installed(state, editor, installed)
+    _forget_version(state, editor, name)
     save_state(state)
     return True
 
 
-def update_pack(name: str, editor: str) -> bool:
+def pack_update_pending(name: str, editor: str) -> tuple[bool, str, str]:
+    """(needs_update, installed_version, available_version) for one pack."""
+    state = load_state()
+    if name not in _installed_for(state, editor):
+        return False, "", ""
+    pack = find_pack(name)
+    if not pack:
+        return False, _installed_version(state, editor, name), ""
+    available = str(pack.get("version", ""))
+    current = _installed_version(state, editor, name)
+    return current != available, current, available
+
+
+def update_pack(name: str, editor: str, *, force: bool = False) -> bool:
     state = load_state()
     if name not in _installed_for(state, editor):
         print(f"  Plugin '{name}' is not installed for {editor} — use 'install' instead")
         return False
 
-    print(f"  Updating: {name} for {editor}")
+    pending, current, available = pack_update_pending(name, editor)
+    if not pending and not force:
+        # Silent no-op by design: `ai-toolkit update` runs this for every
+        # installed pack on every invocation.
+        return True
+
+    if current and available:
+        print(f"  Updating: {name} for {editor} ({current} -> {available})")
+    else:
+        print(f"  Updating: {name} for {editor}")
     remove_pack(name, editor)
     return install_pack(name, editor)
 
@@ -1090,6 +1148,34 @@ def _show_memory_stats() -> None:
         print(f"    DB: {_human_size(MEMORY_DB.stat().st_size)} (error reading stats)")
 
 
+def _show_pack_status(name: str, pack_dir: Path) -> None:
+    """Let a pack report its own state via scripts/status.py.
+
+    Generic counterpart to the install-time init.py hook. Before this, anything
+    beyond a hook listing meant another hardcoded `if name == ...` branch, which
+    is why memory-pack is the only pack that ever reported anything.
+
+    The script owns its output format; it is indented and shown verbatim.
+    Failure is not an error: status must never be the thing that breaks.
+    """
+    status_script = pack_dir / "scripts" / "status.py"
+    if not status_script.is_file():
+        return
+    try:
+        result = subprocess.run(
+            ["python3", str(status_script)],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        print(f"    (status unavailable: {exc})")
+        return
+    stream = result.stdout if result.stdout.strip() else result.stderr
+    for line in stream.strip().splitlines():
+        print(f"    {line}")
+
+
 def cmd_status(editors: list[str]) -> None:
     state = load_state()
     shown = False
@@ -1117,6 +1203,8 @@ def cmd_status(editors: list[str]) -> None:
                     print(f"    Hooks: {', '.join(h.name for h in hooks)}")
             if name == "memory-pack":
                 _show_memory_stats()
+            else:
+                _show_pack_status(name, Path(pack["_dir"]))
         print()
 
     if not shown and all(not _installed_for(state, editor) for editor in editors):
@@ -1199,24 +1287,56 @@ def _cmd_remove(args: list[str], editors: list[str]) -> None:
 def _cmd_update(args: list[str], editors: list[str]) -> None:
     if not args:
         print("Usage: ai-toolkit plugin update [--editor claude|codex|all] <pack-name> [...]")
-        print("       ai-toolkit plugin update [--editor claude|codex|all] --all")
+        print("       ai-toolkit plugin update [--editor claude|codex|all] --all [--dry-run]")
         sys.exit(1)
+
+    dry_run = "--dry-run" in args or "--list" in args
+    force = "--force" in args
+    everything = "--all" in args
+    explicit = [a for a in args if not a.startswith("--")]
+
     state = load_state()
     for editor in editors:
-        names = list(_installed_for(state, editor)) if "--all" in args else args
+        names = list(_installed_for(state, editor)) if everything else explicit
         if not names:
+            if everything:
+                # Nothing installed is the common case; do not make the core
+                # update noisy about it.
+                continue
             print(f"No plugins installed for {editor}.")
             print()
             continue
-        if "--all" in args:
-            print(f"Updating {len(names)} installed plugin(s) for {editor}...\n")
+
+        if dry_run:
+            pending = []
+            for name in names:
+                needs, current, available = pack_update_pending(name, editor)
+                if needs or force:
+                    pending.append(f"{name} ({current or 'unrecorded'} -> {available or 'unknown'})")
+            if pending:
+                print(f"Would update for {editor}: {', '.join(pending)}")
+            else:
+                print(f"All {len(names)} pack(s) up to date for {editor}")
+            print()
+            continue
+
         ok = 0
+        failed: list[str] = []
         for name in names:
-            if update_pack(name, editor):
-                ok += 1
-            print()
-        if "--all" in args:
+            try:
+                if update_pack(name, editor, force=force):
+                    ok += 1
+                else:
+                    failed.append(name)
+            except Exception as exc:  # noqa: BLE001
+                # A pack failure must never abort the run: `ai-toolkit update`
+                # calls this after the core update has already succeeded.
+                print(f"  WARN update failed for {name}: {exc}")
+                failed.append(name)
+        if everything and (failed or force):
             print(f"Updated: {ok}/{len(names)} packs for {editor}")
+            if failed:
+                print(f"  Failed: {', '.join(failed)}")
             print()