# Understanding the Three Layers of the Reverse-Skill Routing Architecture

> Explore the three layers of the reverse-skill routing architecture: Shared, Windows, and Kali Linux. Understand core skill definitions and platform-specific tooling for efficient routing.

- Repository: [ZhaoXu/reverse-skill](https://github.com/zhaoxuya520/reverse-skill)
- Tags: architecture
- Published: 2026-08-22

---

**The reverse-skill routing architecture consists of three distinct layers: a Shared (Platform-Independent) Layer containing core skill definitions, a Windows Platform Layer with PowerShell tooling, and a Kali Linux Platform Layer with Bash utilities.**

The **reverse-skill** repository by `zhaoxuya520` implements a sophisticated routing system that separates platform-agnostic logic from OS-specific implementations. This three-tier design enables the framework to maintain a unified skill catalog while executing environment-specific workflows on Windows and Kali Linux.

## The Three-Layer Architecture Overview

According to the [`docs/ARCHITECTURE.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/docs/ARCHITECTURE.md) documentation, the reverse-skill routing system implements a clear separation of concerns across three distinct tiers. The **"多平台支持架构"** diagram illustrates how these layers interact to provide platform-agnostic flexibility combined with OS-specific tooling.

### Layer 1: Shared (Platform-Independent) Layer

The foundation of the architecture resides in the `skills/` folder, which houses all platform-neutral components. This layer contains [`SKILL.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/SKILL.md) (the entry point skill aggregator), [`routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/routing.md) (the routing matrix), and the `CTF-Sandbox-Orchestrator` sub-skills.

Key responsibilities include:

- Providing the **core skill catalog** and routing matrix used to match user intents
- Maintaining the `field-journal/` directory for automatic evolution mechanisms
- Storing documentation generators and reference files that work on any OS
- Defining the master routing logic in [`skills/scripts/master-route.sh`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/scripts/master-route.sh)

This shared layer ensures that skill definitions and routing logic remain portable across operating systems.

### Layer 2: Windows Platform Layer

Windows-specific functionality is isolated under the `skills/scripts/` directory using PowerShell automation. The Windows layer handles tooling that requires Windows APIs or package management via Winget.

Key components include:

- `skills/scripts/bootstrap-reverse.ps1` – The Windows bootstrap script for self-installation of missing utilities
- [`skills/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/bootstrap-manifest.json) – Defines Winget and GitHub Release ZIP dependencies
- [`skills/RULES.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/RULES.md) – Contains Windows-specific security rules and constraints

When the routing engine detects a Windows environment, it executes PowerShell scripts with execution policies bypassed to install dependencies and enforce platform-specific security policies.

### Layer 3: Kali Linux Platform Layer

Linux-specific support is organized under the `kali/` directory structure, utilizing Bash scripting and native package managers. This layer targets penetration testing workflows specific to Kali distributions.

Key components include:

- `kali/scripts/*.sh` – Bash implementations of platform-specific tooling
- [`kali/scripts/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/kali/scripts/bootstrap-manifest.json) – Defines APT, pip, npm, and GitHub tar.gz dependencies
- [`kali/RULES-kali.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/kali/RULES-kali.md) – Enforces Kali-specific security rules and operational constraints

The Kali layer provides package management via `apt`, Python pip, and Node npm, ensuring security tools are properly installed before skill execution.

## How the Layers Interact

The routing engine implements a cascading selection mechanism defined in [`skills/routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/routing.md). First, the system reads the shared skill definitions from [`SKILL.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/SKILL.md), then selects the appropriate platform-layer scripts based on the current environment.

The internal layer selection logic operates as follows:

```python
import platform, json, pathlib

def select_manifest():
    sys = platform.system()
    if sys == "Windows":
        return pathlib.Path("skills/bootstrap-manifest.json")
    else:  # assumes Kali-compatible Linux

        return pathlib.Path("kali/scripts/bootstrap-manifest.json")

```

This conditional routing ensures that Windows hosts receive PowerShell execution paths while Linux systems default to Kali-compatible Bash workflows.

## Practical Implementation Examples

### Platform-Agnostic Skill Invocation

To invoke the master routing entry point on any Unix-like system:

```bash

# Linux / macOS / Kali

bash skills/scripts/master-route.sh --hint "pwn-chain"

```

This command triggers the shared layer routing logic, which then delegates to platform-specific implementations based on the detected environment.

### Windows Bootstrap Execution

For Windows environments requiring tool installation:

```powershell

# Windows PowerShell

powershell -NoProfile -ExecutionPolicy Bypass -File skills/scripts/bootstrap-reverse.ps1

```

This execution pattern references the second layer, handling Winget installations and GitHub Release ZIP extractions defined in the Windows manifest.

### Manifest Selection Logic

The following Python demonstrates how the routing architecture selects between platform layers at runtime:

```python
import platform, json, pathlib

def select_manifest():
    sys = platform.system()
    if sys == "Windows":
        return pathlib.Path("skills/bootstrap-manifest.json")
    else:  # assumes Kali‑compatible Linux

        return pathlib.Path("kali/scripts/bootstrap-manifest.json")

```

This function determines whether to load Windows-specific dependencies from [`skills/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/bootstrap-manifest.json) or Kali-specific packages from [`kali/scripts/bootstrap-manifest.json`](https://github.com/zhaoxuya520/reverse-skill/blob/main/kali/scripts/bootstrap-manifest.json).

## Summary

The reverse-skill routing architecture achieves platform flexibility through three carefully separated layers:

- **Shared Layer** (`skills/`): Contains portable skill definitions, routing matrices, and the `field-journal/` auto-evolution system
- **Windows Layer** (`skills/scripts/`): Provides PowerShell automation, Winget package management, and Windows-specific security rules
- **Kali Linux Layer** (`kali/`): Implements Bash tooling, APT/pip/npm package installation, and penetration-testing-specific constraints

## Frequently Asked Questions

### How does the routing engine decide which layer to use?

The routing engine first loads the shared skill definitions from [`skills/SKILL.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/SKILL.md) and [`skills/routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/routing.md), then queries the operating system via `platform.system()` to determine whether to execute Windows PowerShell scripts or Kali Linux Bash utilities. This selection happens automatically before any skill workflow begins execution.

### What file triggers the skill routing process?

The entry point is [`skills/SKILL.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/SKILL.md), which aggregates all available skills and routes. This file references the routing matrix in [`skills/routing.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/skills/routing.md) to match user intents with appropriate platform-layer implementations.

### Can the reverse-skill architecture support additional operating systems?

The current implementation explicitly handles Windows via `skills/scripts/bootstrap-reverse.ps1` and assumes all other systems are Kali-compatible Linux. To add macOS or other distributions, you would create a new platform layer following the pattern established in `kali/scripts/`, including a new bootstrap manifest and OS-specific rules file.

### Where is the three-layer architecture visually documented?

The **"多平台支持架构"** diagram in [`docs/ARCHITECTURE.md`](https://github.com/zhaoxuya520/reverse-skill/blob/main/docs/ARCHITECTURE.md) provides a visual representation of how the Shared, Windows, and Kali Linux layers interact. This document defines the architectural boundaries and file organization patterns used throughout the repository.