# NousResearch/hermes-agent · Discord /skill slash command exceeds 8KB payload limit

## Open now

- Nothing open on GitHub.

These issues and pull requests all concern a Discord slash command sync problem where the /skill command group exceeds the 8000-byte payload limit. Multiple fix approaches are represented, including splitting by category, using autocomplete, and enforcing size limits.

## TL;DR

- 9 member(s): 0 open issue(s), 3 closed issue(s), 0 open PR(s), 1 merged PR(s), 5 PR(s) closed without merging.
- A fix was merged to main in PR #11580. Verify it addresses your case.
- **Recommended:** read PR #11580 (and any competing PRs below) before filing. Confirm the merged change covers your symptom.

## Maintainer resolution verdict

- Internal-tracker verdict over this cluster's issue members: `partially_resolved` · deciding PR(s): `pr-11580`. This is distinct from the fix status above. Weigh it yourself.

## How this cluster was grouped

- Link evidence (`STRUCTURAL_PARTIAL`): some members are connected by structural evidence (shared changed files, or a closing/superseded reference); the rest are joined by an automated relevance judgement over their text.
- Members outside that structural core may belong to a different underlying problem.
- Pairwise link density `0.22`: the share of member pairs that carry a link, counting a structural link in full and a relevance-only link at 0.36. `1.00` means every pair is linked.

## Closed / duplicate issues

- #10259: Discord slash command sync fails with error 50035 when /skill group exceeds 8KB payload limit
- #10550: Discord: /skill group exceeds 8000-byte limit causing CommandSyncFailure on startup
- #11321: \[Bug\]: Discord slash command sync fails: group 'skill' exceeds maximum size (8000)

## Prior & competing PRs

- **#11580: fix(discord): flat /skill command with autocomplete — fits 8KB limit trivially**. merged to main · fix tier `verified`
  - maintainer direction: category `merged`; implication `superseded`
  - files: `gateway/platforms/discord.py`, `tests/gateway/test_discord_slash_commands.py`
  - fix hunks:
  - `gateway/platforms/discord.py`

    ```diff
    @@ -1955,12 +1955,23 @@ async def _handler(interaction: discord.Interaction):
             self._register_skill_group(tree)
     
         def _register_skill_group(self, tree) -> None:
    -        """Register a ``/skill`` command group with category subcommand groups.
    -
    -        Skills are organized by their directory category under ``SKILLS_DIR``.
    -        Each category becomes a subcommand group; root-level skills become
    -        direct subcommands.  Discord supports 25 subcommand groups × 25
    -        subcommands each = 625 skills — well beyond the old 100-command cap.
    +        """Register a single ``/skill`` command with autocomplete on the name.
    +
    +        Discord enforces an ~8000-byte per-command payload limit. The older
    +        nested layout (``/skill <category> <name>``) registered one giant
    +        command whose serialized payload grew linearly with the skill
    +        catalog — with the default ~75 skills the payload was ~14 KB and
    +        ``tree.sync()`` rejected the entire slash-command batch (issues
    +        #11321, #10259, #11385, #10261, #10214).
    +
    +        Autocomplete options are fetched dynamically by Discord when the
    +        user types — they do NOT count against the per-command registration
    +        budget. So we register ONE flat ``/skill`` command with
    +        ``name: str`` (autocompleted) and ``args: str = ""``. This scales
    +        to thousands of skills with no size math, no splitting, and no
    +        hidden skills. The slash picker also becomes more discoverable —
    +        Discord live-filters by the user's typed prefix against both the
    +        skill name and its description.
             """
             try:
                 from hermes_cli.commands import discord_skill_commands_by_category
    ```

    ```diff
    @@ -1971,68 +1982,97 @@ def _register_skill_group(self, tree) -> None:
                 except Exception:
                     pass
     
    +            # Reuse the existing collector for consistent filtering
    +            # (per-platform disabled, hub-excluded, name clamping), then
    +            # flatten — the category grouping was only useful for the
    +            # nested layout.
                 categories, uncategorized, hidden = discord_skill_commands_by_category(
                     reserved_names=existing_names,
                 )
    +            entries: list[tuple[str, str, str]] = list(uncategorized)
    +            for cat_skills in categories.values():
    +                entries.extend(cat_skills)
     
    -            if not categories and not uncategorized:
    +            if not entries:
                     return
     
    -            skill_group = discord.app_commands.Group(
    -                name="skill",
    -                description="Run a Hermes skill",
    -            )
    +            # Stable alphabetical order so the autocomplete suggestion
    +            # list is predictable across restarts.
    +            entries.sort(key=lambda t: t[0])
     
    -            # ── Helper: build a callback for a skill command key ──
    -            def _make_handler(_key: str):
    -                @discord.app_commands.describe(args="Optional arguments for the skill")
    -                async def _handler(interaction: discord.Interaction, args: str = ""):
    -                    await self._run_simple_slash(interaction, f"{_key} {args}".strip())
    -                _handler.__name__ = f"skill_{_key.lstrip('/').replace('-', '_')}"
    -                return _handler
    -
    -            # ── Uncategorized (root-level) skills → direct subcommands ──
    -            for discord_name, description, cmd_key in uncategorized:
    -                cmd = discord.app_commands.Command(
    -                    name=discord_name,
    -                    description=description or f"Run the {discord_name} skill",
    -                    callback=_make_handler(cmd_key),
    -                )
    -                skill_group.add_command(cmd)
    -
    -            # ── Category subcommand groups ──
    -            for cat_name in sorted(categories):
    -                cat_desc = f"{cat_name.replace('-', ' ').title()} skills"
    -                if len(cat_desc) > 100:
    -                    cat_desc = cat_desc[:97] + "..."
    -                cat_group = discord.app_commands.Group(
    -                    name=cat_name,
    -                    description=cat_desc,
    -                    parent=skill_group,
    -                )
    -                for discord_name, description, cmd_key in categories[cat_name]:
    -                    cmd = discord.app_commands.Command(
    -                        name=discord_name,
    -                        description=description or f"Run the {discord_name} skill",
    -                        callback=_make_handler(cmd_key),
    +            # name -> (description, cmd_key) — used by both the autocomplete
    +            # callback and the handler for O(1) dispatch.
    +            skill_lookup: dict[str, tuple[str, str]] = {
    +                n: (d, k) for n, d, k in entries
    +            }
    +
    +            async def _autocomplete_name(
    +                interaction: "discord.Interaction", current: str,
    +            ) -> list:
    +                """Filter skills by the user's typed prefix.
    +
    +                Matches both the skill name and its description so
    +                "/skill pdf" surfaces skills whose description mentions
    +                PDFs even if the name doesn't. Discord caps this list at
    +                25 entries per query.
    +                """
    +                q = (current or "").strip().lower()
    +                choices: list = []
    +                for name, desc, _key in entries:
    +                    if not q or q in name.lower() or (desc and q in desc.lower()):
    +                        if desc:
    +                            label = f"{name} — {desc}"
    +                        else:
    +                            label = name
    +                        # Discord's Choice.name is capped at 100 chars.
    +                        if len(label) > 100:
    +                            label = label[:97] + "..."
    +                        choices.append(
    +                            discord.app_commands.Choice(name=label, value=name)
    +                        )
    +                        if len(choices) >= 25:
    +                            break
    +                return choices
    +
    +            @discord.app_commands.describe(
    +                name="Which skill to run",
    +                args="Optional arguments for the skill",
    +            )
    +            @discord.app_commands.autocomplete(name=_autocomplete_name)
    +            async def _skill_handler(
    +                interaction: "discord.Interaction", name: str, args: str = "",
    +            ):
    +                entry = skill_lookup.get(name)
    +                if not entry:
    +                    await interaction.response.send_message(
    +                        f"Unknown skill: `{name}`. Start typing for "
    +                        f"autocomplete suggestions.",
    +                        ephemeral=True,
                         )
    -                    cat_group.add_command(cmd)
    +                    return
    +                _desc, cmd_key = entry
    +                await self._run_simple_slash(
    +                    interaction, f"{cmd_key} {args}".strip()
    +                )
     
    -            tree.add_command(skill_group)
    +            cmd = discord.app_commands.Command(
    +                name="skill",
    +                description="Run a Hermes skill",
    +                callback=_skill_handler,
    +            )
    +            tree.add_command(cmd)
     
    -            total = sum(len(v) for v in categories.values()) + len(uncategorized)
                 logger.info(
    -                "[%s] Registered /skill group: %d skill(s) across %d categories"
    -                " + %d uncategorized",
    -                self.name, total, len(categories), len(uncategorized),
    +                "[%s] Registered /skill command with %d skill(s) via autocomplete",
    +                self.name, len(entries),
                 )
                 if hidden:
    -                logger.warning(
    -                    "[%s] %d skill(s) not registered (Discord subcommand limits)",
    +                logger.info(
    +                    "[%s] %d skill(s) filtered out of /skill (name clamp / reserved)",
                         self.name, hidden,
                     )
             except Exception as exc:
    -            logger.warning("[%s] Failed to register /skill group: %s", self.name, exc)
    +            logger.warning("[%s] Failed to register /skill command: %s", self.name, exc)
     
         def _build_slash_event(self, interaction: discord.Interaction, text: str) -> MessageEvent:
             """Build a MessageEvent from a Discord slash command interaction."""
    ```
  - `tests/gateway/test_discord_slash_commands.py`

    ```diff
    @@ -11,52 +11,66 @@
     
     def _ensure_discord_mock():
         if "discord" in sys.modules and hasattr(sys.modules["discord"], "__file__"):
    +        # Real discord is installed — nothing to do.
             return
     
    -    discord_mod = MagicMock()
    -    discord_mod.Intents.default.return_value = MagicMock()
    -    discord_mod.DMChannel = type("DMChannel", (), {})
    -    discord_mod.Thread = type("Thread", (), {})
    -    discord_mod.ForumChannel = type("ForumChannel", (), {})
    -    discord_mod.Interaction = object
    -
    -    # Lightweight mock for app_commands.Group and Command used by
    -    # _register_skill_group.
    -    class _FakeGroup:
    -        def __init__(self, *, name, description, parent=None):
    -            self.name = name
    -            self.description = description
    -            self.parent = parent
    -            self._children: dict[str, object] = {}
    -            if parent is not None:
    -                parent.add_command(self)
    -
    -        def add_command(self, cmd):
    -            self._children[cmd.name] = cmd
    -
    -    class _FakeCommand:
    -        def __init__(self, *, name, description, callback, parent=None):
    -            self.name = name
    -            self.description = description
    -            self.callback = callback
    -            self.parent = parent
    -
    -    discord_mod.app_commands = SimpleNamespace(
    -        describe=lambda **kwargs: (lambda fn: fn),
    -        choices=lambda **kwargs: (lambda fn: fn),
    -        Choice=lambda **kwargs: SimpleNamespace(**kwargs),
    -        Group=_FakeGroup,
    -        Command=_FakeCommand,
    -    )
    -
    -    ext_mod = MagicMock()
    -    commands_mod = MagicMock()
    -    commands_mod.Bot = MagicMock
    -    ext_mod.commands = commands_mod
    -
    -    sys.modules.setdefault("discord", discord_mod)
    -    sys.modules.setdefault("discord.ext", ext_mod)
    -    sys.modules.setdefault("discord.ext.commands", commands_mod)
    +    if sys.modules.get("discord") is None:
    +        discord_mod = MagicMock()
    +        discord_mod.Intents.default.return_value = MagicMock()
    +        discord_mod.DMChannel = type("DMChannel", (), {})
    +        discord_mod.Thread = type("Thread", (), {})
    +        discord_mod.ForumChannel = type("ForumChannel", (), {})
    +        discord_mod.Interaction = object
    +
    +        # Lightweight mock for app_commands.Group and Command used by
    +        # _register_skill_group.
    +        class _FakeGroup:
    +            def __init__(self, *, name, description, parent=None):
    +                self.name = name
    +                self.description = description
    +                self.parent = parent
    +                self._children: dict[str, object] = {}
    +                if parent is not None:
    +                    parent.add_command(self)
    +
    +            def add_command(self, cmd):
    +                self._children[cmd.name] = cmd
    +
    +        class _FakeCommand:
    +            def __init__(self, *, name, description, callback, parent=None):
    +                self.name = name
    +                self.description = description
    +                self.callback = callback
    +                self.parent = parent
    +
    +        discord_mod.app_commands = SimpleNamespace(
    +            describe=lambda **kwargs: (lambda fn: fn),
    +            choices=lambda **kwargs: (lambda fn: fn),
    +            autocomplete=lambda **kwargs: (lambda fn: fn),
    +            Choice=lambda **kwargs: SimpleNamespace(**kwargs),
    +            Group=_FakeGroup,
    +            Command=_FakeCommand,
    +        )
    +
    +        ext_mod = MagicMock()
    +        commands_mod = MagicMock()
    +        commands_mod.Bot = MagicMock
    +        ext_mod.commands = commands_mod
    +
    +        sys.modules["discord"] = discord_mod
    +        sys.modules.setdefault("discord.ext", ext_mod)
    +        sys.modules.setdefault("discord.ext.commands", commands_mod)
    +
    +    # Whether we just installed the mock OR another test module installed
    +    # it first via its own _ensure_discord_mock, force the decorators we
    +    # need onto discord.app_commands — the flat /skill command uses
    +    # @app_commands.autocomplete and not every other mock stub exposes it.
    +    _app = getattr(sys.modules["discord"], "app_commands", None)
    +    if _app is not None and not hasattr(_app, "autocomplete"):
    +        try:
    +            _app.autocomplete = lambda **kwargs: (lambda fn: fn)
    +        except Exception:
    +            pass
     
     
     _ensure_discord_mock()
    ```

    ```diff
    @@ -599,12 +613,19 @@ def test_discord_auto_thread_config_bridge(monkeypatch, tmp_path):
     
     
     # ------------------------------------------------------------------
    -# /skill group registration
    +# /skill command registration (flat + autocomplete)
     # ------------------------------------------------------------------
     
     
    -def test_register_skill_group_creates_group(adapter):
    -    """_register_skill_group should register a '/skill' Group on the tree."""
    +def test_register_skill_command_is_flat_not_nested(adapter):
    +    """_register_skill_group should register a single flat ``/skill`` command.
    +
    +    The older layout nested categories as subcommand groups under ``/skill``.
    +    That registered as one giant command whose serialized payload exceeded
    +    Discord's 8KB per-command limit with the default skill catalog. The
    +    flat layout sidesteps the limit — autocomplete options are fetched
    +    dynamically by Discord and don't count against the registration budget.
    +    """
         mock_categories = {
             "creative": [
                 ("ascii-art", "Generate ASCII art", "/ascii-art"),
    ```

    ```diff
    @@ -625,22 +646,17 @@ def test_register_skill_group_creates_group(adapter):
             adapter._register_slash_commands()
     
         tree = adapter._client.tree
    -    assert "skill" in tree.commands, "Expected /skill group to be registered"
    -    skill_group = tree.commands["skill"]
    -    assert skill_group.name == "skill"
    -    # Should have 2 category subgroups + 1 uncategorized subcommand
    -    children = skill_group._children
    -    assert "creative" in children
    -    assert "media" in children
    -    assert "dogfood" in children
    -    # Category groups should have their skills
    -    assert "ascii-art" in children["creative"]._children
    -    assert "excalidraw" in children["creative"]._children
    -    assert "gif-search" in children["media"]._children
    -
    -
    -def test_register_skill_group_empty_skills_no_group(adapter):
    -    """No /skill group should be added when there are zero skills."""
    +    assert "skill" in tree.commands, "Expected /skill command to be registered"
    +    skill_cmd = tree.commands["skill"]
    +    assert skill_cmd.name == "skill"
    +    # Flat command — NOT a Group — so it has no _children of category subgroups
    +    assert not hasattr(skill_cmd, "_children") or not getattr(skill_cmd, "_children", {}), (
    +        "Flat /skill command should not have subcommand children"
    +    )
    +
    +
    +def test_register_skill_command_empty_skills_no_command(adapter):
    +    """No /skill command should be registered when there are zero skills."""
         with patch(
             "hermes_cli.commands.discord_skill_commands_by_category",
             return_value=({}, [], 0),
    ```

    ```diff
    @@ -651,13 +667,134 @@ def test_register_skill_group_empty_skills_no_group(adapter):
         assert "skill" not in tree.commands
     
     
    -def test_register_skill_group_handler_dispatches_command(adapter):
    -    """Skill subcommand handlers should dispatch the correct /cmd-key text."""
    +def test_register_skill_command_callback_dispatches_by_name(adapter):
    +    """The /skill callback should look up the skill by ``name`` and
    +    dispatch via ``_run_simple_slash`` with the real command key.
    +    """
         mock_categories = {
             "media": [
                 ("gif-search", "Search for GIFs", "/gif-search"),
             ],
         }
    +    mock_uncategorized = [
    +        ("dogfood", "QA testing", "/dogfood"),
    +    ]
    +
    +    with patch(
    +        "hermes_cli.commands.discord_skill_commands_by_category",
    +        return_value=(mock_categories, mock_uncategorized, 0),
    +    ):
    +        adapter._register_slash_commands()
    +
    +    skill_cmd = adapter._client.tree.commands["skill"]
    +    assert skill_cmd.callback is not None
    +
    +    # Stub out _run_simple_slash so we can verify the dispatched text.
    +    dispatched: list[str] = []
    +
    +    async def fake_run(_interaction, text):
    +        dispatched.append(text)
    +
    +    adapter._run_simple_slash = fake_run
    +
    +    import asyncio
    +
    +    fake_interaction = SimpleNamespace()
    +    # gif-search → /gif-search with no args
    +    asyncio.run(skill_cmd.callback(fake_interaction, name="gif-search"))
    +    # dogfood with args
    +    asyncio.run(skill_cmd.callback(fake_interaction, name="dogfood", args="my test"))
    +
    +    assert dispatched == ["/gif-search", "/dogfood my test"]
    +
    +
    +def test_register_skill_command_handles_unknown_skill_gracefully(adapter):
    +    """Passing a name that isn't a registered skill should respond with
    +    an ephemeral error message, NOT crash the callback.
    +    """
    +    with patch(
    +        "hermes_cli.commands.discord_skill_commands_by_category",
    +        return_value=({"media": [("gif-search", "GIFs", "/gif-search")]}, [], 0),
    +    ):
    +        adapter._register_slash_commands()
    +
    +    skill_cmd = adapter._client.tree.commands["skill"]
    +
    +    sent: list[dict] = []
    +
    +    async def fake_send(text, ephemeral=False):
    +        sent.append({"text": text, "ephemeral": ephemeral})
    +
    +    interaction = SimpleNamespace(
    +        response=SimpleNamespace(send_message=fake_send),
    +    )
    +
    +    import asyncio
    +    asyncio.run(skill_cmd.callback(interaction, name="does-not-exist"))
    +
    +    assert len(sent) == 1
    +    assert "Unknown skill" in sent[0]["text"]
    +    assert "does-not-exist" in sent[0]["text"]
    +    assert sent[0]["ephemeral"] is True
    +
    +
    +def test_register_skill_command_payload_fits_discord_8kb_limit(adapter):
    +    """The /skill command registration payload must stay under Discord's
    +    ~8000-byte per-command limit even with a large skill catalog.
    +
    +    This is the regression guard for #11321 / #10259. Simulates 500 skills
    +    (20 categories × 25 — the hard cap per category in the collector) and
    +    confirms the serialized command still fits. Autocomplete options are
    +    not part of this payload, so the budget is essentially constant.
    +    """
    +    import json
    +
    +    # Simulate the largest catalog the collector will ever produce:
    +    # 20 categories × 25 skills each, with verbose 100-char descriptions.
    +    large_categories: dict[str, list[tuple[str, str, str]]] = {}
    +    long_desc = "A verbose description padded to approximately 100 chars " + "." * 42
    +    for i in range(20):
    +        cat = f"cat{i:02d}"
    +        large_categories[cat] = [
    +            (f"skill-{i:02d}-{j:02d}", long_desc, f"/skill-{i:02d}-{j:02d}")
    +            for j in range(25)
    +        ]
    +
    +    with patch(
    +        "hermes_cli.commands.discord_skill_commands_by_category",
    +        return_value=(large_categories, [], 0),
    +    ):
    +        adapter._register_slash_commands()
    +
    +    skill_cmd = adapter._client.tree.commands["skill"]
    +    # Approximate the serialized registration payload (name + description only).
    +    # Autocomplete options are NOT registered — they're fetched dynamically.
    +    payload = json.dumps({
    +        "name": skill_cmd.name,
    +        "description": skill_cmd.description,
    +        "options": [
    +            {"name": "name", "description": "Which skill to run", "type": 3, "required": True},
    +            {"name": "args", "description": "Optional arguments for the skill", "type": 3, "required": False},
    +        ],
    +    })
    +    assert len(payload) < 500, (
    +        f"Flat /skill command payload is ~{len(payload)} bytes — the whole "
    +        f"point of this design is that it stays small regardless of skill count"
    +    )
    +
    +
    +def test_register_skill_command_autocomplete_filters_by_name_and_description(adapter):
    +    """The autocomplete callback should match on both skill name and
    +    description so the user can search by either.
    +    """
    +    mock_categories = {
    +        "ocr": [
    +            ("ocr-and-documents", "Extract text from PDFs and scanned documents", "/ocr-and-documents"),
    +        ],
    +        "media": [
    +            ("gif-search", "Search and download GIFs from Tenor", "/gif-search"),
    +        ],
    +    }
     
         with patch(
             "hermes_cli.commands.discord_skill_commands_by_category",
    ```

    ```diff
    @@ -665,10 +802,15 @@ def test_register_skill_group_handler_dispatches_command(adapter):
         ):
             adapter._register_slash_commands()
     
    -    skill_group = adapter._client.tree.commands["skill"]
    -    media_group = skill_group._children["media"]
    -    gif_cmd = media_group._children["gif-search"]
    -    assert gif_cmd.callback is not None
    -    # The callback name should reflect the skill
    -    assert "gif_search" in gif_cmd.callback.__name__
    +    skill_cmd = adapter._client.tree.commands["skill"]
    +    # The callback has been wrapped with @autocomplete(name=...) — in our mock
    +    # the decorator is pass-through, so we inspect the closed-over list by
    +    # invoking the registered autocomplete function directly through the
    +    # test API. Since the mock doesn't preserve the autocomplete binding,
    +    # we re-derive the filter by building the same entries list.
    +    #
    +    # What we CAN verify at this layer: the callback dispatches correctly
    +    # (covered in other tests). The autocomplete filter itself is exercised
    +    # via direct function call in the real-discord integration path.
    +    assert skill_cmd.callback is not None
     
    ```
- **#10261: fix(discord): split /skill group per-category when payload exceeds 8KB**. closed without merge
  - maintainer direction: category `superseded_by_pr`; implication `superseded`; refs `#11580`, `#10259`, `#11580`
- **#11385: fix(discord): keep skill slash group within size limit**. closed without merge
  - maintainer direction: category `superseded_by_pr`; implication `superseded`; refs `#11580`
- **#11404: fix: enforce Discord 8000-char limit on /skill command group**. closed without merge
  - maintainer direction: category `stale_abandoned`; implication `active`
- **#11552: fix: Discord /skill group exceeds 8000-char command size limit**. closed without merge
  - maintainer direction: category `implemented_elsewhere`; implication `superseded`; refs `d7fb435e0`, `d7fb435e0ec41070564981532ab04cc0e5a3c42d`, `#11580`, `#11321`
- **#14156: fix: avoid oversized Discord skill sync payloads**. closed without merge
  - maintainer direction: category `implemented_elsewhere`; implication `superseded`; refs `d7fb435e0`, `d7fb435e0`, `#11580`, `#11321`, `#10259`, `#11580`, `#10667`, `#10667`

## Fix status

- Merged to main in PR #11580 (cited above). No release data is tracked. Verify downstream.
- Fix last verified (merged) `2026-04-17`. This confirmation is old and may be out of date (a revert/reopen would not have invalidated it here); re-verify.