@@ -637,10 +637,16 @@ def _fetch_skills(
         except SkillRefNotFoundError as exc:
             # The ref does not exist upstream, so waiting for the network
             # cannot help. Core's message already names where the ref came
-            # from; only a ref the user did not type needs the way to
-            # choose another.
+            # from. A ref typed with --ref needs nothing more; one from the
+            # environment needs the way out of it, as login and the plugin
+            # refresh give; any other needs --ref.
             advice = "No skills were installed."
-            if exc.ref_source not in ("--ref", REF_ENV_VAR):
+            if exc.ref_source == REF_ENV_VAR:
+                advice += (
+                    f" Set {REF_ENV_VAR} to another ref, or unset it to use "
+                    "the pinned release."
+                )
+            elif exc.ref_source != "--ref":
                 advice += " Pass --ref to choose another deepgram/skills ref."
             raise click.ClickException(f"{exc}\n\n{advice}")
         except SkillFetchError as exc:
 
@@ -298,10 +298,15 @@ def test_fetch_error_becomes_a_click_exception(self, message):
     @pytest.mark.parametrize(
         ("ref_source", "last_line"),
         [
-            # The user typed the ref, or set the env var: core's message
-            # already says which, so there is nothing to add.
+            # The user typed the ref: core's message already says so, so
+            # there is nothing to add.
             ("--ref", "No skills were installed."),
-            (REF_ENV_VAR, "No skills were installed."),
+            # The env var: how to get out of it, as login and plugin say.
+            (
+                REF_ENV_VAR,
+                f"No skills were installed. Set {REF_ENV_VAR} to another ref, "
+                "or unset it to use the pinned release.",
+            ),
             # A ref the user did not type: --ref is the way to another.
             (
                 PINNED_REF_SOURCE,
@@ -329,6 +334,54 @@ def test_a_missing_ref_ends_without_network_advice(self, ref_source, last_line):
         assert "network" not in rendered
         assert "Retry" not in rendered
 
+    @pytest.mark.parametrize("subcommand", ["install", "update"])
+    def test_a_missing_env_var_ref_says_how_to_change_it(
+        self, monkeypatch, capsys, subcommand
+    ):
+        """It ended with a bare "No skills were installed." and no way out."""
+        import urllib.error
+
+        monkeypatch.setenv(REF_ENV_VAR, "no-such-ref-zz9")
+        generator = MagicMock()
+        generator.cli_name = "claude"
+        generator.display_name = "Claude Code"
+        generator.detect.return_value = True
+        generator.install_conflicts.return_value = []
+        not_found = urllib.error.HTTPError("https://x", 404, "Not Found", {}, None)
+        state = {"installed_skills": {"claude": {"paths": [], "skills_ref": "main"}}}
+        cmd = SkillsCommand()
+        with (
+            patch(
+                "deepctl_core.skill_generator.get_all_generators",
+                return_value=[generator],
+            ),
+            patch(
+                "deepctl_core.skill_generator.collect_command_metadata",
+                return_value=[],
+            ),
+            patch("deepctl_core.skill_generator.get_skills_state", return_value=state),
+            patch("deepctl_core.skill_generator.save_skills_state") as save,
+            patch(
+                "deepctl_core.skill_bundle.urllib.request.urlopen",
+                side_effect=not_found,
+            ),
+            pytest.raises(click.ClickException) as excinfo,
+        ):
+            if subcommand == "install":
+                cmd._handle_install(cli_name="claude")
+            else:
+                cmd._handle_update()
+
+        rendered = str(excinfo.value)
+        assert f"which came from {REF_ENV_VAR}." in rendered
+        assert rendered.splitlines()[-1] == (
+            f"No skills were installed. Set {REF_ENV_VAR} to another ref, "
+            "or unset it to use the pinned release."
+        )
+        assert "Pass --ref" not in rendered
+        generator.install_skills.assert_not_called()
+        save.assert_not_called()
+
     def test_a_network_error_keeps_the_network_advice(self):
         exc = SkillFetchError(
             "Could not download deepgram/skills@main from https://x: "
 
@@ -138,6 +138,11 @@ def __init__(self, ref: str, url: str, ref_source: str | None = None) -> None:
             f"{SKILLS_REPO} has no ref {ref!r} (HTTP 404 from {url}). {where}"
         )
 
+    def __reduce__(self) -> tuple[Any, ...]:
+        # BaseException pickles and copies by calling the class with
+        # ``self.args``, which here is only the formatted message.
+        return (type(self), (self.ref, self.url, self.ref_source))
+
     def advice(self, command: str) -> str:
         """What to do instead of retrying, for a caller that takes no --ref.
 
 
@@ -104,12 +104,17 @@ class SkillsStateLockTimeout(SkillsStateError):
 
     def __init__(self, lock_path: Path, holder: str = "process") -> None:
         self.lock_path = lock_path
+        self.holder = holder
         super().__init__(
             f"Another deepctl {holder} holds the skill records lock at "
             f"{lock_path}. Wait for it to finish and retry; the lock is "
             "released automatically when that process exits."
         )
 
+    def __reduce__(self) -> tuple[Any, ...]:
+        # BaseException rebuilds from ``self.args`` (the message alone).
+        return (type(self), (self.lock_path, self.holder))
+
 
 class SkillOwnershipError(Exception):
     """A destination already exists and deepctl did not put it there.
@@ -134,6 +139,10 @@ def __init__(self, conflicts: Sequence[tuple[str, Path]]) -> None:
             "was installed."
         )
 
+    def __reduce__(self) -> tuple[Any, ...]:
+        # BaseException rebuilds from ``self.args`` (the message alone).
+        return (type(self), (self.conflicts,))
+
 
 # ---------------------------------------------------------------------------
 # Data model
 
@@ -1,10 +1,12 @@
 """Unit tests for the upstream skill bundle fetcher."""
 
+import copy
 import http.client
 import importlib.metadata
 import io
 import json
 import os
+import pickle
 import sys
 import tarfile
 import time
@@ -828,3 +830,25 @@ def test_pruning_tolerates_a_missing_root_and_non_directories(self, tmp_path):
         os.utime(stale_file, (two_hours_ago, two_hours_ago))
         skill_bundle._prune_stale_dirs(cache)
         assert stale_file.is_file()
+
+
+class TestSkillRefNotFoundErrorRoundTrips:
+    """Its __init__ takes three arguments, but BaseException rebuilds a
+    copy or an unpickled error from ``args``, which held only the message."""
+
+    @pytest.mark.parametrize("ref_source", [None, "--ref", REF_ENV_VAR])
+    @pytest.mark.parametrize(
+        "clone",
+        [lambda e: pickle.loads(pickle.dumps(e)), copy.copy, copy.deepcopy],
+        ids=["pickle", "copy", "deepcopy"],
+    )
+    def test_ref_not_found_error_survives_pickle_and_copy(self, clone, ref_source):
+        exc = SkillRefNotFoundError("no-such-ref-zz9", "https://x/y", ref_source)
+
+        again = clone(exc)
+
+        assert type(again) is SkillRefNotFoundError
+        assert again.ref == "no-such-ref-zz9"
+        assert again.url == "https://x/y"
+        assert again.ref_source == ref_source
+        assert str(again) == str(exc)
@@ -1,8 +1,10 @@
 """Unit tests for skill generator module."""
 
+import copy
 import json
 import multiprocessing
 import os
+import pickle
 import re
 import shutil
 import threading
@@ -3062,3 +3064,37 @@ class TestWithAdvice:
     )
     def test_joins_with_exactly_one_full_stop(self, detail, joined):
         assert skill_generator.with_advice(detail, "Retry.").endswith(joined)
+
+
+_CLONES = pytest.mark.parametrize(
+    "clone",
+    [lambda e: pickle.loads(pickle.dumps(e)), copy.copy, copy.deepcopy],
+    ids=["pickle", "copy", "deepcopy"],
+)
+
+
+class TestSkillErrorsRoundTrip:
+    """BaseException rebuilds a copy or an unpickled error from ``args``,
+    which for these held only the formatted message, not the arguments."""
+
+    @_CLONES
+    def test_lock_timeout_survives_pickle_and_copy(self, clone, tmp_path):
+        exc = SkillsStateLockTimeout(tmp_path / "skills.lock", holder="thread")
+
+        again = clone(exc)
+
+        assert type(again) is SkillsStateLockTimeout
+        assert again.lock_path == tmp_path / "skills.lock"
+        assert again.holder == "thread"
+        assert str(again) == str(exc)
+
+    @_CLONES
+    def test_ownership_error_survives_pickle_and_copy(self, clone, tmp_path):
+        conflicts = [("api", tmp_path / "api"), ("docs", tmp_path / "docs")]
+        exc = SkillOwnershipError(conflicts)
+
+        again = clone(exc)
+
+        assert type(again) is SkillOwnershipError
+        assert again.conflicts == conflicts
+        assert str(again) == str(exc)