sequence

Plugin/Skill Runtime Sequence

Output a practical sequence view of how a single /plugin:command invocation is executed in Claude Code.

1) Summary

Start with a short 3-item summary:

• what the user invoked
• what dispatch boundary handled the request
• where behavior is defined (command vs skill + shared conventions)

2) Mermaid sequence diagram

Always include this sequence template and replace placeholders with plugin names if provided:

sequenceDiagram
    autonumber
    actor User
    participant UI as Claude Code UI
    participant PluginRuntime as Plugin Runtime
    participant Command as plugin command (`/<plugin>:<command>`)
    participant Skill as skill logic (`skills/<name>/SKILL.md`)
    participant Core as shared logic (`jx-core` or sibling dependency)
    participant Tools as allowlisted tools
    participant Outputs as file updates / external systems

    User->>UI: invoke /<plugin>:<command> [args]
    UI->>PluginRuntime: resolve plugin and command allowlist
    PluginRuntime->>Command: load command doc metadata
    Command->>Skill: dispatch to SKILL.md behavior
    Skill->>PluginRuntime: execute ordered steps
    PluginRuntime->>Tools: run allowed tools only
    Tools-->>PluginRuntime: structured results
    alt command depends on shared conventions
        PluginRuntime->>Core: read ../../../jx-core/_shared docs/scripts
        Core-->>PluginRuntime: shared IDs, schemas, and conversion logic
    end
    PluginRuntime->>Outputs: write pages, files, or response
    Skill-->>UI: render final output
    UI-->>User: confirmed completion and findings

3) Mapping map

Then provide this exact map with plugin-specific values if available:

• Commands: commands/<command>.md
• Behavior: skills/<command>/SKILL.md with user-invocable: true
• Runtime policy: allowed-tools in command frontmatter
• Shared dependencies: .claude-plugin/plugin.json dependency graph
• Execution script entrypoints: scripts/* used by skills
• Install/discovery: .claude-plugin/plugin.json + .claude-plugin/marketplace.json

3) Verification checklist

• Is there a 1:1 command-to-user-invocable-skill mapping for all user-facing commands?
• Do commands and skills live in the same plugin namespace prefix?
• Are shared behaviors factored into dependency plugins instead of duplicate copies?
• Are tool grants strictly scoped to the minimum required for each command?

If topic is "complete architecture of claude code", append this short line:

Architecture is convention-first: slash command → skill instruction → allowlisted tools/shared conventions → response.