diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1f5a3d0f..02dec480 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,9 +29,24 @@ history.
   release, or one of the build's releases). The builder's message is carried
   whole up to 8 KiB, so the blocking deployment ids it names are no longer lost
   to the 1000-byte cap on the raw body.
+- `comfy knowledge pick CAPABILITY --check-local` checks each `oss` pick's
+  template against the local ComfyUI's model folders, the same check
+  `comfy templates check` runs. A pick whose model files are missing gets
+  `available_locally: false`, an `unavailable_reason` and a `missing_models`
+  count, and a template absent from a fresh gallery index is flagged too. A pick
+  that could not be checked carries its own `local_check` naming why. The
+  payload's `local_check` is `ok` when the check ran. When the server is down, a
+  model folder listing is over the size cap, or the gallery cannot load, it
+  carries that error code and no pick is marked. The flag is off by default
+  because it fetches uncached template workflows and calls the local server.
 
 ### Fixed
 
+- `comfy templates check` returns an error envelope instead of a traceback when
+  the gallery or workflow fetch gets a non-200 status or an over-cap body, or
+  when a model folder listing is over the size cap. It also percent-encodes the
+  model folder name it asks the local server for, accepts a folder name with
+  `..` inside it, and refreshes a stale gallery index before looking up the name.
 - A failed blob upload during `comfy build push` no longer writes the presigned
   PUT URL's query string to stdout, into the JSON envelope, or into a CI log.
   Both a rejected upload and a dropped connection quote the URL they were talking
diff --git a/comfy_cli/command/knowledge.py b/comfy_cli/command/knowledge.py
index d5449206..135a8078 100644
--- a/comfy_cli/command/knowledge.py
+++ b/comfy_cli/command/knowledge.py
@@ -2,7 +2,7 @@
 
     comfy knowledge status [--refresh]
     comfy knowledge resolve <alias-or-id>
-    comfy knowledge pick [capability]
+    comfy knowledge pick [capability] [--check-local]
 
 Backed by :mod:`comfy_cli.knowledge`. JSON mode is the contract; pretty mode
 is a short courtesy view.
@@ -181,6 +181,63 @@ def _emit_capabilities(renderer, bundle: knowledge.Bundle, *, query: str | None
     renderer.emit(payload, command="knowledge pick")
 
 
+def _check_picks_locally(picks: list[dict[str, Any]]) -> str:
+    """Flag each ``oss`` pick whose template the local ComfyUI cannot run.
+
+    Returns ``ok`` when the check ran. A pick that could not be checked carries
+    its own ``local_check`` instead of a flag. A failure that would repeat for
+    every pick (server down, no gallery) returns its error code instead and
+    marks nothing.
+    """
+    from comfy_cli.command import templates as templates_cmd
+
+    marks: list[tuple[dict[str, Any], dict[str, Any]]] = []
+    listings: dict[str, list[str] | None] = {}
+    rows: list[dict[str, Any]] | None = None
+    index_fresh = False
+    try:
+        for pick in picks:
+            template = pick.get("template")
+            if pick.get("route") != "oss" or not template:
+                continue
+            if rows is None:
+                rows = templates_cmd._gallery_rows(None, refresh=False)
+                # A failed re-fetch serves the stale cache, which cannot show that
+                # a template is absent upstream.
+                index_fresh = not templates_cmd._cache_is_stale(templates_cmd._cache_path())
+            try:
+                _row, wf = templates_cmd._template_workflow(template, rows, refresh=False)
+            except templates_cmd.TemplateCheckError as e:
+                if e.code == "template_not_found" and index_fresh:
+                    flag = {"available_locally": False, "unavailable_reason": knowledge.UNAVAILABLE_TEMPLATE_NOT_FOUND}
+                    marks.append((pick, flag))
+                else:
+                    marks.append((pick, {"local_check": e.code}))
+                continue
+            required = templates_cmd._collect_model_requirements(wf)
+            _present, missing, _warnings = templates_cmd._match_local_models(required, listings)
+            verdict = templates_cmd._compute_verdict(
+                api_dependent=False,
+                missing=missing,
+                required_count=len(required),
+                node_types=templates_cmd._collect_node_class_types(wf),
+            )
+            if verdict == "unknown":
+                marks.append((pick, {"local_check": "unknown"}))
+            elif missing:
+                if all(listings.get(m["directory"]) is None for m in missing):
+                    reason = knowledge.UNAVAILABLE_MODEL_FOLDER_NOT_FOUND
+                else:
+                    reason = knowledge.UNAVAILABLE_MISSING_MODELS
+                flag = {"available_locally": False, "unavailable_reason": reason, "missing_models": len(missing)}
+                marks.append((pick, flag))
+    except templates_cmd.TemplateCheckError as e:
+        return e.code
+    for pick, mark in marks:
+        pick.update(mark)
+    return "ok"
+
+
 @app.command("pick", help="Ranked model picks for a capability; omit it to list every capability.")
 @tracking.track_command("knowledge")
 def pick_cmd(
@@ -188,6 +245,16 @@ def pick_cmd(
         str | None,
         typer.Argument(help="Capability id (e.g. lipsync, text-to-video). Omit to list every capability."),
     ] = None,
+    check_local: Annotated[
+        bool,
+        typer.Option(
+            "--check-local",
+            help=(
+                "Check each oss pick's template against the local ComfyUI's model folders and flag "
+                "the picks it cannot run. Fetches uncached template workflows and calls the local server."
+            ),
+        ),
+    ] = False,
 ):
     renderer = get_renderer()
     bundle = _require_bundle(renderer)
@@ -218,15 +285,21 @@ def pick_cmd(
         "compiled_at": bundle.compiled_at,
         "stale": bundle.stale,
     }
+    if check_local:
+        payload["local_check"] = _check_picks_locally(picks)
     if renderer.is_pretty():
         from rich.table import Table
 
         columns = ("rank", "model", "route", "template", "status", "caveat", "best_for")
+        if check_local:
+            columns += ("unavailable_reason", "local_check")
         tbl = Table(show_header=True, header_style="bold")
         for col in columns:
             tbl.add_column(col)
         for p in picks:
             cells = {**p, "best_for": ", ".join(p.get("best_for") or [])}
-            tbl.add_row(*(sanitize_markup("" if cells[c] is None else cells[c]) for c in columns))
+            tbl.add_row(*(sanitize_markup("" if cells.get(c) is None else cells[c]) for c in columns))
         renderer.console().print(tbl)
+        if check_local and payload["local_check"] != "ok":
+            rprint(f"[yellow]local check did not finish:[/yellow] {payload['local_check']}")
     renderer.emit(payload, command="knowledge pick")
diff --git a/comfy_cli/command/templates.py b/comfy_cli/command/templates.py
index 578ff58f..fe9ecf8b 100644
--- a/comfy_cli/command/templates.py
+++ b/comfy_cli/command/templates.py
@@ -1322,7 +1322,7 @@ def _list_local_folder(target, folder: str) -> list[str] | None:
     # Reuse the exact target/URL plumbing `comfy models list-folder` uses.
     from comfy_cli.command.models.search import _http_get_json, _models_path_parts
 
-    url = target.url(*_models_path_parts(target), folder)
+    url = target.url(*_models_path_parts(target), urllib.parse.quote(folder, safe=""))
     try:
         data = _http_get_json(url, target)
     except urllib.error.HTTPError as e:
@@ -1365,53 +1365,41 @@ def _compute_verdict(*, api_dependent: bool, missing: list, required_count: int,
     return "unknown" if loaderish else "runnable"
 
 
-@app.command(
-    "check",
-    help=(
-        "Report whether a gallery template is runnable on THIS install: which of "
-        "its models are present vs missing locally, whether it needs partner-API "
-        "access, and any custom nodes it declares. Resolves the name against the "
-        "gallery, fetches the workflow, and intersects its model refs with the "
-        "local server's model folders."
-    ),
-)
-@tracking.track_command("templates")
-def check_cmd(
-    name: Annotated[str, typer.Argument(help="Template name (matches `comfy templates ls` rows).")],
-    gallery_path: Annotated[
-        str | None,
-        typer.Option("--gallery", show_default=False, help="Path to a local index.json (skips the cache + fetch)."),
-    ] = None,
-    refresh: Annotated[
-        bool,
-        typer.Option("--refresh", help="Re-fetch the gallery index AND the template workflow before checking."),
-    ] = False,
-):
-    from comfy_cli.target import resolve_target
+class TemplateCheckError(Exception):
+    """A template-check failure, carrying the fields of its error envelope."""
+
+    def __init__(self, code: str, message: str, *, hint: str | None = None, details: dict[str, Any] | None = None):
+        super().__init__(message)
+        self.code = code
+        self.message = message
+        self.hint = hint
+        self.details = details
 
-    renderer = get_renderer()
 
-    # 1. Resolve the name against the gallery index (same affordance as `fetch`).
+def _gallery_rows(gallery_path: str | None, *, refresh: bool) -> list[dict[str, Any]]:
     try:
-        cats = _load_gallery(gallery_path, refresh=refresh)
-    except (urllib.error.URLError, OSError, json.JSONDecodeError) as e:
-        renderer.error(code="gallery_load_failed", message=str(e))
-        raise typer.Exit(code=1) from e
+        cats = _load_gallery(gallery_path, refresh=refresh, background_ok=False)
+    except _GALLERY_LOAD_ERRORS as e:
+        raise TemplateCheckError("gallery_load_failed", str(e)) from e
+    return _flatten_templates(cats)
 
-    rows = _flatten_templates(cats)
+
+def _template_workflow(
+    name: str, rows: list[dict[str, Any]], *, refresh: bool
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    """Resolve ``name`` against the gallery ``rows`` and return ``(row, workflow)``,
+    reading the workflow JSON from the per-template cache or fetching it."""
     match = next((r for r in rows if r["name"] == name), None)
     if match is None:
         lower = name.lower()
         close = [r["name"] for r in rows if lower in r["name"].lower()][:5]
-        renderer.error(
-            code="template_not_found",
-            message=f"no template named {name!r} in the gallery",
+        raise TemplateCheckError(
+            "template_not_found",
+            f"no template named {name!r} in the gallery",
             hint="try `comfy templates ls --name <substring>` to search",
             details={"close_matches": close},
         )
-        raise typer.Exit(code=1)
 
-    # 2. Fetch (or read from cache) the per-template workflow JSON.
     cache_path = _template_workflow_cache_path(name)
     body: bytes | None = None
     if not refresh and cache_path.exists():
@@ -1422,11 +1410,11 @@ def check_cmd(
     if body is None:
         try:
             body = _fetch_template_workflow(name)
-        except (urllib.error.HTTPError, urllib.error.URLError, OSError) as e:
+        except (urllib.error.URLError, OSError, RuntimeError, ResponseTooLarge) as e:
             status = getattr(e, "code", None)
-            renderer.error(
-                code="template_fetch_failed",
-                message=f"failed to fetch workflow for {name!r}: {e}",
+            raise TemplateCheckError(
+                "template_fetch_failed",
+                f"failed to fetch workflow for {name!r}: {e}",
                 hint=(
                     "the gallery index references a template whose workflow JSON "
                     "is missing upstream — report at "
@@ -1435,8 +1423,7 @@ def check_cmd(
                     else "check network connectivity"
                 ),
                 details={"status": status} if status else None,
-            )
-            raise typer.Exit(code=1) from e
+            ) from e
         # Write atomically: a truncated file (interrupted write / full disk) would
         # otherwise be trusted by the read path above on the next non-refresh run
         # and fail `template_workflow_invalid_json` until the user passed --refresh.
@@ -1454,20 +1441,113 @@ def check_cmd(
 
     try:
         wf = json.loads(body)
-    except (json.JSONDecodeError, UnicodeDecodeError) as e:
-        renderer.error(
-            code="template_workflow_invalid_json",
-            message=f"template workflow for {name!r} is not valid JSON: {e}",
+    except (json.JSONDecodeError, UnicodeDecodeError, RecursionError) as e:
+        raise TemplateCheckError(
+            "template_workflow_invalid_json",
+            f"template workflow for {name!r} is not valid JSON: {e}",
             hint="re-run with --refresh to re-fetch, or report upstream",
-        )
-        raise typer.Exit(code=1) from e
+        ) from e
     if not isinstance(wf, dict):
-        renderer.error(
-            code="template_workflow_invalid_json",
-            message=f"template workflow for {name!r} is not a JSON object",
+        raise TemplateCheckError(
+            "template_workflow_invalid_json",
+            f"template workflow for {name!r} is not a JSON object",
             hint="re-run with --refresh to re-fetch, or report upstream",
         )
-        raise typer.Exit(code=1)
+    return match, wf
+
+
+def _match_local_models(
+    required: list[dict[str, str]], listings: dict[str, list[str] | None]
+) -> tuple[list[str], list[dict[str, str]], list[str]]:
+    """Split ``required`` into ``(present, missing, warnings)`` against the local
+    server's model folders, matching by basename.
+
+    ``listings`` caches each folder's listing by directory, so a caller checking
+    several templates lists a shared folder once.
+    """
+    warnings: list[str] = []
+    present: list[str] = []
+    missing: list[dict[str, str]] = []
+    if not required:
+        return present, missing, warnings
+
+    from comfy_cli.command.models.search import _is_walkable_folder_name
+    from comfy_cli.target import resolve_target
+
+    target = resolve_target(where="local")
+    try:
+        for directory in dict.fromkeys(req["directory"] for req in required):
+            if not _is_walkable_folder_name(directory):
+                # Not addressable as a `/models/<folder>` segment — treat as absent.
+                listings[directory] = None
+                warnings.append(
+                    f"model directory {directory!r} isn't a valid model folder — its files are reported missing"
+                )
+                continue
+            if directory not in listings:
+                listings[directory] = _list_local_folder(target, directory)
+            if listings[directory] is None:
+                warnings.append(
+                    f"model folder {directory!r} not found on the local server "
+                    f"(custom-node folder?) — its files are reported missing"
+                )
+    except ResponseTooLarge as e:
+        raise TemplateCheckError(
+            code="model_listing_too_large",
+            message=f"a local model folder listing is over the response size cap: {e}",
+            hint="check that the server on this host:port is ComfyUI",
+        ) from e
+    except (urllib.error.URLError, OSError, ValueError) as e:
+        raise TemplateCheckError(
+            "server_not_running",
+            f"local ComfyUI server is unreachable, cannot check installed models: {e}",
+            hint="run `comfy launch` to start a local server",
+        ) from e
+
+    for req in required:
+        listing = listings.get(req["directory"])
+        # Normalize BOTH sides: a model ref may itself carry a subfolder
+        # (e.g. ``SDXL/model.safetensors``, as ComfyUI loader widgets emit),
+        # so compare basenames on the required side too.
+        req_base = _basename(req["name"])
+        if listing and any(_basename(entry) == req_base for entry in listing):
+            present.append(req["name"])
+        else:
+            missing.append(dict(req))
+    return present, missing, warnings
+
+
+@app.command(
+    "check",
+    help=(
+        "Report whether a gallery template is runnable on THIS install: which of "
+        "its models are present vs missing locally, whether it needs partner-API "
+        "access, and any custom nodes it declares. Resolves the name against the "
+        "gallery, fetches the workflow, and intersects its model refs with the "
+        "local server's model folders."
+    ),
+)
+@tracking.track_command("templates")
+def check_cmd(
+    name: Annotated[str, typer.Argument(help="Template name (matches `comfy templates ls` rows).")],
+    gallery_path: Annotated[
+        str | None,
+        typer.Option("--gallery", show_default=False, help="Path to a local index.json (skips the cache + fetch)."),
+    ] = None,
+    refresh: Annotated[
+        bool,
+        typer.Option("--refresh", help="Re-fetch the gallery index AND the template workflow before checking."),
+    ] = False,
+):
+    renderer = get_renderer()
+
+    # 1-2. Resolve the name against the gallery index (same affordance as `fetch`)
+    #      and read the per-template workflow JSON from cache or fetch it.
+    try:
+        match, wf = _template_workflow(name, _gallery_rows(gallery_path, refresh=refresh), refresh=refresh)
+    except TemplateCheckError as e:
+        renderer.error(code=e.code, message=e.message, hint=e.hint, details=e.details)
+        raise typer.Exit(code=1) from e
 
     # 3. Model requirements (top-level + subgraph walk) and node class types.
     required = _collect_model_requirements(wf)
@@ -1498,47 +1578,11 @@ def check_cmd(
 
     # 5. Installed intersection: list each distinct folder once on the local server
     #    and match required files by basename.
-    warnings: list[str] = []
-    present: list[str] = []
-    missing: list[dict[str, str]] = []
-    distinct_dirs = list(dict.fromkeys(req["directory"] for req in required))
-    if required:
-        target = resolve_target(where="local")
-        listings: dict[str, list[str] | None] = {}
-        try:
-            for directory in distinct_dirs:
-                if not directory or ".." in directory or "/" in directory or "\\" in directory:
-                    # Not addressable as a `/models/<folder>` segment — treat as absent.
-                    listings[directory] = None
-                    warnings.append(
-                        f"model directory {directory!r} isn't a valid model folder — its files are reported missing"
-                    )
-                    continue
-                folder_files = _list_local_folder(target, directory)
-                listings[directory] = folder_files
-                if folder_files is None:
-                    warnings.append(
-                        f"model folder {directory!r} not found on the local server "
-                        f"(custom-node folder?) — its files are reported missing"
-                    )
-        except (urllib.error.URLError, OSError, ValueError, json.JSONDecodeError) as e:
-            renderer.error(
-                code="server_not_running",
-                message=f"local ComfyUI server is unreachable, cannot check installed models: {e}",
-                hint="run `comfy launch` to start a local server",
-            )
-            raise typer.Exit(code=1) from e
-
-        for req in required:
-            listing = listings.get(req["directory"])
-            # Normalize BOTH sides: a model ref may itself carry a subfolder
-            # (e.g. ``SDXL/model.safetensors``, as ComfyUI loader widgets emit),
-            # so compare basenames on the required side too.
-            req_base = _basename(req["name"])
-            if listing and any(_basename(entry) == req_base for entry in listing):
-                present.append(req["name"])
-            else:
-                missing.append(dict(req))
+    try:
+        present, missing, warnings = _match_local_models(required, {})
+    except TemplateCheckError as e:
+        renderer.error(code=e.code, message=e.message, hint=e.hint, details=e.details)
+        raise typer.Exit(code=1) from e
 
     # 6. Custom nodes are report-only in v1 (surfaced verbatim, not verified).
     custom_nodes_required = list(match.get("requires_custom_nodes") or [])
diff --git a/comfy_cli/error_codes.py b/comfy_cli/error_codes.py
index 0756b69b..bbfd8d91 100644
--- a/comfy_cli/error_codes.py
+++ b/comfy_cli/error_codes.py
@@ -355,6 +355,12 @@ class ErrorCode:
         "of `/` and `\\`; for `model download`, choose the destination directory with "
         "`--relative-path` instead",
     ),
+    ErrorCode(
+        "model_listing_too_large",
+        "A local model folder listing was over the response size cap, so `templates check` or "
+        "`knowledge pick --check-local` could not check which model files are installed.",
+        "check that the server on this host:port is ComfyUI",
+    ),
     ErrorCode(
         "folder_not_found",
         "Cloud or local server returned 404 for the requested model folder.",
diff --git a/comfy_cli/knowledge.py b/comfy_cli/knowledge.py
index 950c9bdc..8f9ee7a5 100644
--- a/comfy_cli/knowledge.py
+++ b/comfy_cli/knowledge.py
@@ -59,6 +59,10 @@
 MAX_VERSION_CHARS = 64
 
 UNAVAILABLE_LOCALLY = "the templates or nodes this row resolves to are absent from this install"
+# `knowledge pick --check-local` reasons, kept short: each flagged pick repeats one.
+UNAVAILABLE_MISSING_MODELS = "model files are missing locally"
+UNAVAILABLE_TEMPLATE_NOT_FOUND = "template is not in the gallery"
+UNAVAILABLE_MODEL_FOLDER_NOT_FOUND = "model folder not found locally"
 
 # Grammatical filler dropped before subset matching. Deliberately generic English:
 # naming a capability, model or gallery tag here would be a second copy of the
diff --git a/comfy_cli/schemas/knowledge.json b/comfy_cli/schemas/knowledge.json
index ae9875a3..bc089938 100644
--- a/comfy_cli/schemas/knowledge.json
+++ b/comfy_cli/schemas/knowledge.json
@@ -56,9 +56,14 @@
           "status": { "type": ["string", "null"], "description": "Copied from the pick's model row when that row exists." },
           "superseded_by": { "type": ["string", "null"], "description": "From the deprecations list or the pick's model row." },
           "best_for": { "type": "array", "items": { "type": "string" }, "maxItems": 1, "description": "Head of the model row's best_for list, present only when the row has one. The caveat is per capability; this is the row's own routing opinion." },
-          "fits": { "type": "object", "description": "The model row's fits block (vram_gb per variant, a credit rate, max_refs, source), present only when the row carries one." }
+          "fits": { "type": "object", "description": "The model row's fits block (vram_gb per variant, a credit rate, max_refs, source), present only when the row carries one." },
+          "available_locally": { "type": "boolean", "const": false, "description": "Present only under pick --check-local, on an oss pick the local ComfyUI cannot run." },
+          "unavailable_reason": { "type": "string", "description": "Why available_locally is false (pick --check-local): model files are missing, their model folder is not on the local server, or the template is not in a gallery index confirmed fresh." },
+          "missing_models": { "type": "integer", "minimum": 1, "description": "How many of the pick template's model files the local ComfyUI lacks (pick --check-local). `comfy templates check <template>` names them with download URLs." },
+          "local_check": { "type": "string", "description": "Present only under pick --check-local, on an oss pick that could not be checked, which carries no available_locally either way. The error code that stopped it (template_fetch_failed, template_workflow_invalid_json, or template_not_found when the gallery index could not be confirmed fresh), or `unknown` when the template declares no model files but loads models." }
         }
       }
-    }
+    },
+    "local_check": { "type": "string", "description": "Present only under pick --check-local. `ok` when the check ran, though a pick may still carry its own local_check. Otherwise the error code that stopped the check (server_not_running, model_listing_too_large, gallery_load_failed), and no pick is marked." }
   }
 }
diff --git a/comfy_cli/skills/comfy/SKILL.md b/comfy_cli/skills/comfy/SKILL.md
index 6ce57ee7..b19181cd 100644
--- a/comfy_cli/skills/comfy/SKILL.md
+++ b/comfy_cli/skills/comfy/SKILL.md
@@ -85,6 +85,13 @@ rather than an answer to anything. Five rules:
    it resolves to. A row flagged this way also pulls in `picks[]` for the
    capabilities that rank it, so the highest-ranked entry *without* the flag is
    the runnable alternative. Say what is missing, then name that alternative.
+   When routing is local, add `--check-local` to `knowledge pick`: it also
+   flags an `oss` pick whose model files are missing, with `missing_models`
+   counting them, and `comfy --json templates check <template>` names them with
+   download URLs. Unless the payload's `local_check` is `ok`, the check did not
+   finish and no pick is flagged. A pick carrying its own `local_check` was not
+   checked, so it is not yet the runnable alternative. Ask before downloading
+   anything.
 3. **Verify before denying.** A missing `knowledge` key or a `nudge` means
    nothing is curated for that query, not that it is unsupported. A `nudge` on
    a block that still carries rows means your search term matched nothing
diff --git a/tests/comfy_cli/command/test_templates.py b/tests/comfy_cli/command/test_templates.py
index 0fe34eba..9a9a03dc 100644
--- a/tests/comfy_cli/command/test_templates.py
+++ b/tests/comfy_cli/command/test_templates.py
@@ -673,19 +673,22 @@ def test_check_basename_match_against_subfoldered_listing(gallery_file, tmp_path
     assert env["data"]["models"]["present"] == ["v1-5-pruned-emaonly.safetensors"]
 
 
-def test_check_server_down_surfaces_server_not_running(gallery_file, tmp_path, monkeypatch):
+@pytest.mark.parametrize(
+    "exc, code", [("url_error", "server_not_running"), (ResponseTooLarge("too big"), "model_listing_too_large")]
+)
+def test_check_listing_failure_surfaces_its_error_code(gallery_file, tmp_path, monkeypatch, exc, code):
     import urllib.error
 
     _force_json_renderer()
     _no_local_server(monkeypatch)
     _stub_template_workflow_fetch(monkeypatch, json.dumps(_TOP_LEVEL_WF).encode())
-    _stub_folder_listing(monkeypatch, urllib.error.URLError("connection refused"))
+    _stub_folder_listing(monkeypatch, urllib.error.URLError("connection refused") if exc == "url_error" else exc)
 
     result = _run_check(gallery_file, "image_z_image", tmp_path, monkeypatch)
     assert result.exit_code != 0
     env = _envelope(result.output)
     assert env["ok"] is False
-    assert env["error"]["code"] == "server_not_running"
+    assert env["error"]["code"] == code
 
 
 def test_check_unknown_template_surfaces_template_not_found(gallery_file, tmp_path, monkeypatch):
@@ -806,12 +809,13 @@ def test_check_api_source_stays_index_when_object_info_finds_nothing(gallery_fil
     assert env["data"]["api"]["api_nodes"] == []
 
 
-def test_check_invalid_utf8_workflow_surfaces_invalid_json(gallery_file, tmp_path, monkeypatch):
-    # Invalid UTF-8 in the cached/fetched body raises UnicodeDecodeError (not a
-    # subclass of JSONDecodeError) — it must be caught as a clean error, not crash.
+@pytest.mark.parametrize("body", [b"\xff\xfe not valid utf-8", b"[" * 100_000], ids=["non_utf8", "deep_nesting"])
+def test_check_invalid_utf8_workflow_surfaces_invalid_json(gallery_file, tmp_path, monkeypatch, body):
+    # Invalid UTF-8 raises UnicodeDecodeError and deep nesting raises RecursionError,
+    # neither a JSONDecodeError — both must be caught as a clean error, not crash.
     _force_json_renderer()
     _no_local_server(monkeypatch)
-    _stub_template_workflow_fetch(monkeypatch, b"\xff\xfe not valid utf-8")
+    _stub_template_workflow_fetch(monkeypatch, body)
 
     result = _run_check(gallery_file, "image_z_image", tmp_path, monkeypatch)
     assert result.exit_code != 0
@@ -819,6 +823,49 @@ def test_check_invalid_utf8_workflow_surfaces_invalid_json(gallery_file, tmp_pat
     assert env["error"]["code"] == "template_workflow_invalid_json"
 
 
+@pytest.mark.parametrize("exc", [RuntimeError("template workflow fetch failed: HTTP 204"), ResponseTooLarge("big")])
+def test_check_non_200_or_over_cap_workflow_surfaces_fetch_failed(gallery_file, tmp_path, monkeypatch, exc):
+    _force_json_renderer()
+    _no_local_server(monkeypatch)
+    _stub_template_workflow_fetch(monkeypatch, exc)
+
+    result = _run_check(gallery_file, "image_z_image", tmp_path, monkeypatch)
+    assert result.exit_code != 0
+    env = _envelope(result.output)
+    assert env["error"]["code"] == "template_fetch_failed"
+
+
+def test_check_wrong_shape_gallery_surfaces_gallery_load_failed(tmp_path, monkeypatch):
+    _force_json_renderer()
+    bad = tmp_path / "bad.json"
+    bad.write_text('{"error": "rate limited"}')
+
+    result = _run_check(str(bad), "image_z_image", tmp_path, monkeypatch)
+    assert result.exit_code != 0
+    env = _envelope(result.output)
+    assert env["error"]["code"] == "gallery_load_failed"
+
+
+def test_local_folder_listing_encodes_the_folder_as_one_segment(monkeypatch):
+    from comfy_cli.command.models import search
+    from comfy_cli.target import Target
+
+    urls = []
+    monkeypatch.setattr(search, "_http_get_json", lambda url, target: urls.append(url) or [])
+    target = Target(kind="local", base_url="http://127.0.0.1:8188")
+    templates_cmd._list_local_folder(target, "checkpoints#x")
+    assert urls == ["http://127.0.0.1:8188/models/checkpoints%23x"]
+
+
+def test_match_local_models_lists_a_folder_with_dots_inside_its_name(monkeypatch):
+    _stub_folder_listing(monkeypatch, {"model..v2": ["a.safetensors"]})
+    monkeypatch.setattr("comfy_cli.target.resolve_target", lambda **_kw: None)
+    present, missing, warnings = templates_cmd._match_local_models(
+        [{"name": "a.safetensors", "directory": "model..v2", "url": ""}], {}
+    )
+    assert (present, missing, warnings) == (["a.safetensors"], [], [])
+
+
 # ---------------------------------------------------------------------------
 # Gallery cache TTL: fresh-within-TTL serves the cache, expired
 # re-fetches, and a fetch failure on an expired cache falls back to stale.
diff --git a/tests/comfy_cli/test_knowledge.py b/tests/comfy_cli/test_knowledge.py
index ef883e0c..1321f30a 100644
--- a/tests/comfy_cli/test_knowledge.py
+++ b/tests/comfy_cli/test_knowledge.py
@@ -1067,6 +1067,170 @@ def test_fixture_manifest_matches_fixture(self):
         assert manifest["files"]["knowledge.json"]["bytes"] == len(raw)
 
 
+class TestPickCheckLocal:
+    """`pick --check-local` against the fixture's lipsync table: oss picks testlx,
+    testwan1-talk, testwan2 and testvoice carry templates; lipco-3, testface and
+    testvid are partner picks and must never be checked."""
+
+    OSS_TEMPLATES = ("video_testlx_ia2v", "video_testwan1_talk", "video_testwan2_s2v", "audio-testvoice_tts")
+
+    @pytest.fixture(autouse=True)
+    def _stubs(self, tmp_path, monkeypatch):
+        from comfy_cli.command import templates as templates_cmd
+
+        monkeypatch.delenv("COMFY_CACHE_DIR", raising=False)
+        _env_bundle(tmp_path, monkeypatch)
+        self.monkeypatch = monkeypatch
+        self.templates_cmd = templates_cmd
+        self.fetched: list[str] = []
+        self.listed: list[str] = []
+        self.undeclared_models = False
+        self.set_gallery(self.OSS_TEMPLATES)
+        self.set_installed({"checkpoints": []})
+        monkeypatch.setattr(templates_cmd, "_cache_is_stale", lambda _path: False)
+
+        def _fetch(name, **_kw):
+            self.fetched.append(name)
+            if name == "video_testwan1_talk" and self.undeclared_models:
+                return json.dumps({"nodes": [{"id": 1, "type": "CheckpointLoaderSimple"}]}).encode()
+            models = [{"name": f"{name}.safetensors", "directory": "checkpoints", "url": "https://example.test/m"}]
+            if name == "video_testwan2_s2v":
+                models.append({"name": "testwan2_vae.safetensors", "directory": "vae", "url": "https://example.test/v"})
+            return json.dumps(
+                {"nodes": [{"id": 1, "type": "CheckpointLoaderSimple", "properties": {"models": models}}]}
+            ).encode()
+
+        monkeypatch.setattr(templates_cmd, "_fetch_template_workflow", _fetch)
+
+    def set_gallery(self, names, exc=None):
+        def _load(_path, **kw):
+            self.gallery_kwargs = kw
+            if exc is not None:
+                raise exc
+            return [{"type": "video", "templates": [{"name": n} for n in names]}]
+
+        self.monkeypatch.setattr(self.templates_cmd, "_load_gallery", _load)
+
+    def set_installed(self, mapping_or_exc):
+        def _list(_target, folder):
+            self.listed.append(folder)
+            if isinstance(mapping_or_exc, Exception):
+                raise mapping_or_exc
+            return mapping_or_exc.get(folder)
+
+        self.monkeypatch.setattr(self.templates_cmd, "_list_local_folder", _list)
+
+    def _picks(self, capsys, *extra):
+        rc, env = _run(["pick", "lipsync", *extra], capsys)
+        assert rc == 0
+        _validate(env["data"])
+        return env["data"], {p["model"]: p for p in env["data"]["picks"]}
+
+    def test_flags_oss_picks_missing_model_files(self, capsys):
+        self.set_installed({"checkpoints": ["video_testwan1_talk.safetensors"]})
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        for model, count in (("testlx", 1), ("testwan2", 2), ("testvoice", 1)):
+            assert by_model[model]["available_locally"] is False
+            assert by_model[model]["unavailable_reason"] == knowledge.UNAVAILABLE_MISSING_MODELS
+            assert by_model[model]["missing_models"] == count
+        assert "available_locally" not in by_model["testwan1-talk"]
+        for partner in ("lipco-3", "testface", "testvid"):
+            assert "available_locally" not in by_model[partner]
+        assert sorted(self.fetched) == sorted(self.OSS_TEMPLATES)
+        assert self.listed == ["checkpoints", "vae"]
+        assert self.gallery_kwargs == {"refresh": False, "background_ok": False}
+
+    def test_template_missing_from_the_gallery_is_flagged_without_a_count(self, capsys):
+        self.set_gallery([t for t in self.OSS_TEMPLATES if t != "video_testwan2_s2v"])
+        self.set_installed({"checkpoints": [f"{t}.safetensors" for t in self.OSS_TEMPLATES]})
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        assert by_model["testwan2"]["unavailable_reason"] == knowledge.UNAVAILABLE_TEMPLATE_NOT_FOUND
+        assert "missing_models" not in by_model["testwan2"]
+        assert [m for m, p in by_model.items() if "available_locally" in p] == ["testwan2"]
+
+    def test_a_stale_gallery_index_leaves_a_template_it_lacks_unchecked(self, capsys, monkeypatch):
+        monkeypatch.setattr(self.templates_cmd, "_cache_is_stale", lambda _path: True)
+        self.set_gallery([t for t in self.OSS_TEMPLATES if t != "video_testwan2_s2v"])
+        self.set_installed({"checkpoints": [f"{t}.safetensors" for t in self.OSS_TEMPLATES]})
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        assert by_model["testwan2"]["local_check"] == "template_not_found"
+        assert not any("available_locally" in p for p in by_model.values())
+
+    def test_a_folder_the_server_does_not_have_gets_its_own_reason(self, capsys):
+        self.set_installed({"checkpoints": [f"{t}.safetensors" for t in self.OSS_TEMPLATES]})
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        assert by_model["testwan2"]["unavailable_reason"] == knowledge.UNAVAILABLE_MODEL_FOLDER_NOT_FOUND
+        assert by_model["testwan2"]["missing_models"] == 1
+        assert [m for m, p in by_model.items() if "available_locally" in p] == ["testwan2"]
+
+    def test_a_loader_with_no_declared_models_is_unknown(self, capsys):
+        self.undeclared_models = True
+        self.set_installed({"checkpoints": [f"{t}.safetensors" for t in self.OSS_TEMPLATES], "vae": []})
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        assert by_model["testwan1-talk"]["local_check"] == "unknown"
+        assert "available_locally" not in by_model["testwan1-talk"]
+
+    @pytest.mark.parametrize(
+        "exc", [urllib.error.URLError("offline"), RuntimeError("HTTP 204"), ResponseTooLarge("too big")]
+    )
+    def test_a_failed_workflow_fetch_marks_only_that_pick_unchecked(self, capsys, monkeypatch, exc):
+        real_fetch = self.templates_cmd._fetch_template_workflow
+
+        def _fetch(name, **kw):
+            if name == "video_testlx_ia2v":
+                raise exc
+            return real_fetch(name, **kw)
+
+        monkeypatch.setattr(self.templates_cmd, "_fetch_template_workflow", _fetch)
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "ok"
+        assert by_model["testlx"]["local_check"] == "template_fetch_failed"
+        assert "available_locally" not in by_model["testlx"]
+        assert "local_check" not in by_model["testwan2"]
+        assert by_model["testwan2"]["missing_models"] == 2
+
+    @pytest.mark.parametrize(
+        "server_exc, code",
+        [
+            (urllib.error.URLError("connection refused"), "server_not_running"),
+            (ResponseTooLarge("too big"), "model_listing_too_large"),
+        ],
+    )
+    def test_a_server_failure_drops_flags_already_made(self, capsys, server_exc, code):
+        # testlx is rank 1 and absent from the gallery, so it is flagged before the
+        # first folder listing fails.
+        self.set_gallery([t for t in self.OSS_TEMPLATES if t != "video_testlx_ia2v"])
+        self.set_installed(server_exc)
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == code
+        assert not any("available_locally" in p for p in by_model.values())
+
+    @pytest.mark.parametrize(
+        "gallery_exc", [urllib.error.URLError("offline"), RuntimeError("wrong-shape index"), ResponseTooLarge("big")]
+    )
+    def test_a_gallery_that_cannot_load_flags_nothing(self, capsys, gallery_exc):
+        self.set_gallery((), exc=gallery_exc)
+        data, by_model = self._picks(capsys, "--check-local")
+        assert data["local_check"] == "gallery_load_failed"
+        assert not any("available_locally" in p for p in by_model.values())
+
+    def test_without_the_flag_nothing_is_checked(self, capsys):
+        self.set_gallery((), exc=AssertionError("gallery touched without --check-local"))
+        data, by_model = self._picks(capsys)
+        assert "local_check" not in data
+        assert self.fetched == []
+        assert not any("available_locally" in p for p in by_model.values())
+
+    def test_pretty_mode_with_the_flag(self, pretty_no_stdout):
+        result = CliRunner().invoke(knowledge_cmd.app, ["pick", "lipsync", "--check-local"], standalone_mode=False)
+        assert result.exception is None, result.exception
+
+
 class TestVerbQueryLog:
     """SKILL.md rule 1 tells the agent a miss records the gap. The verbs are
     what it runs, so they have to feed the same log enrichment feeds."""