> ## Documentation Index
> Fetch the complete documentation index at: https://sdlc-rstack.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Install your framework

> Set up your AI coding framework first, then add RStack to it.

RStack is a plugin, not a standalone app — it runs inside an AI coding
framework. This page gets you from nothing to a framework with RStack installed,
whichever tool you use. Every path ends the same way:

```bash theme={null}
cd your-project
npm install rstack-agents
npx rstack-agents init        # auto-detects your framework
```

<Info>
  **Prerequisite for all frameworks:** Node.js 18 or newer (`node --version`).
  RStack and its dashboard run on Node.
</Info>

## How well does each framework integrate?

| Framework             | Integration            | What you get                                                                                                                                                            |
| --------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Pi**                | 🟢 Native adapter      | All 18 `sdlc_*` tools, lifecycle hooks, gating, auto-launch dashboard                                                                                                   |
| **Claude Code**       | 🟢 First-class         | `init` writes a usage guide + a SessionStart hook; plugin commands                                                                                                      |
| **Tau**               | 🟢 First-class         | Python adapter (community, by Jeomon) bridges to the same harness; guard enforcement wires by shadowing Tau's built-in `terminal`/`write`/`edit` tools                  |
| **Hermes**            | 🟢 First-class         | Python plugin bridges to the same harness; guard enforcement wires on Hermes' real `pre_tool_call` hook                                                                 |
| **Operator**          | 🟡 Wrapped, not native | Python adapter bridges to the same harness; `operator-use` has no plugin-loading mechanism, so RStack ships a `bootstrap.py` you run in place of the `operator` command |
| **Codex CLI**         | 🟡 Asset-based         | RStack agents/skills as context via `AGENTS.md`; no native tool gating                                                                                                  |
| **Gemini CLI**        | 🟡 Asset-based         | RStack agents/skills as context via `GEMINI.md`; no native tool gating                                                                                                  |
| **Any other harness** | 🟡 Universal           | The `.rstack/` state contract + a Node bridge any tool can call                                                                                                         |

🟢 = full governed harness. 🟡 = RStack guides the agent via shared context;
the dashboard, state, and CLI still work, but tool-level gating depends on the host.

***

## Pi

Pi is RStack's native home — the deepest integration.

<Steps>
  <Step title="Install Pi">
    Follow the Pi install guide for your platform, then confirm:

    ```bash theme={null}
    pi --version
    ```
  </Step>

  <Step title="Add RStack to your project">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework pi
    ```

    Pi auto-loads the RStack extension from the package — no manual wiring.
  </Step>

  <Step title="Start a run in your next Pi session">
    ```text theme={null}
    sdlc_start(goal="...")
    ```
  </Step>
</Steps>

Details: [Pi adapter](/adapters/pi).

***

## Claude Code

<Steps>
  <Step title="Install Claude Code">
    Install the Claude Code CLI or IDE extension, then confirm with `claude --version`.
  </Step>

  <Step title="Add RStack + init">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework claude-code
    ```

    This writes `.claude/rstack-sdlc.md` (a usage guide) and a **SessionStart
    hook** so the Business Hub opens every session. If you already have a
    `.claude/settings.json`, RStack leaves a mergeable snippet instead of
    overwriting it.
  </Step>

  <Step title="Install the plugin (adds the /sdlc-* commands)">
    ```text theme={null}
    /plugin marketplace add richard-devbot/SDLC-rstack
    /plugin install sdlc-rstack
    ```

    Then drive the pipeline with `/sdlc-start "<goal>"`, `/sdlc-plan`,
    `/sdlc-build-next`, `/sdlc-validate`, `/sdlc-approve`, `/sdlc-status`,
    `/sdlc-resume` — full list in `plugins/sdlc-rstack/commands/`.
  </Step>
</Steps>

Details: [Claude Code adapter](/adapters/claude-code).

***

## Operator

`operator-use` has no third-party plugin discovery at all — no entry\_points,
no config field, no directory scan. RStack ships `bootstrap.py`: a drop-in
replacement for the `operator` command that wires the plugin before handing
off to the real CLI.

<Steps>
  <Step title="Install Operator + Node">
    Operator is a Python harness (`pip install operator-use`). RStack's
    Operator adapter shells out to a Node bridge, so you also need `node` and
    `npx` on `PATH`.
  </Step>

  <Step title="Add RStack + init">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework operator
    ```
  </Step>

  <Step title="Run the bootstrap in place of `operator`">
    ```bash theme={null}
    python node_modules/rstack-agents/src/integrations/operator/bootstrap.py start
    ```

    This wires all 18 `sdlc_*` tools and the real `BEFORE_TOOL_CALL` guard
    hook, then hands off to the real Typer CLI — every other `operator`
    subcommand behaves identically to a stock install.
  </Step>
</Steps>

Details: [Operator adapter](/adapters/universal).

***

## Tau

Tau ([github.com/Jeomon/Tau](https://github.com/Jeomon/Tau)) is a Python
agent framework. Its documented `tool_call` hook never actually fires
upstream, so RStack's adapter wires enforcement by **shadowing** Tau's
built-in `terminal`/`write`/`edit` tools instead — a real, documented Tau
capability. Adapter contributed by Jeomon.

<Steps>
  <Step title="Install Tau + Node">
    RStack's Tau adapter shells out to the same Node bridge as Operator, so
    you need `node` and `npx` on `PATH`.
  </Step>

  <Step title="Add RStack + init">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework tau
    ```

    `init` writes `rstack-tau.example.json` (auto-detected from `tau.json`,
    `tau_settings.json`, or a `.tau/` directory).
  </Step>

  <Step title="Wire the adapter into Tau settings">
    Merge the `extensions.list` entry from `rstack-tau.example.json` into
    your Tau `settings.json`. Loading the extension registers all `sdlc_*`
    tools **and** shadows Tau's `terminal`/`write`/`edit` tools to route
    through `rstack-agents guard` — destructive actions block until a
    `destructive-action:<taskId>` approval exists.
  </Step>
</Steps>

Details: [Tau adapter](/adapters/universal).

***

## Hermes

Hermes ([github.com/NousResearch/hermes-agent](https://github.com/NousResearch/hermes-agent))
loads RStack as a **plugin** — a directory with a `plugin.yaml` manifest and
an `__init__.py` exposing `register(ctx)`. Its `pre_tool_call` hook is a real
blocking gate, so enforcement wires itself once the plugin is enabled.

<Steps>
  <Step title="Install Hermes + Node">
    RStack's Hermes adapter shells out to the same Node bridge, so you need
    `node` and `npx` on `PATH`.
  </Step>

  <Step title="Add RStack + init">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework hermes
    ```
  </Step>

  <Step title="Install and enable the plugin">
    ```bash theme={null}
    mkdir -p ~/.hermes/plugins/rstack-sdlc
    ln -s "$(pwd)/node_modules/rstack-agents/src/integrations/hermes/rstack_sdlc.py" \
          ~/.hermes/plugins/rstack-sdlc/__init__.py
    ln -s "$(pwd)/node_modules/rstack-agents/src/integrations/hermes/plugin.yaml" \
          ~/.hermes/plugins/rstack-sdlc/plugin.yaml
    hermes plugins enable rstack-sdlc
    ```

    Hermes plugins are opt-in — the loader silently skips a plugin directory
    with no `plugin.yaml`, and a plugin not in `plugins.enabled` never loads.
  </Step>
</Steps>

Details: [Hermes adapter](/adapters/universal).

***

## Codex CLI

Codex integrates through shared context files (no native tool binding yet).

<Steps>
  <Step title="Install the Codex CLI">
    Install per its docs and confirm it runs in your project.
  </Step>

  <Step title="Add RStack and bring in the assets">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework custom
    ```

    Then point Codex at the RStack agents via `AGENTS.md`. See the
    [Codex adapter](/adapters/codex) for the exact `AGENTS.md` block.
  </Step>

  <Step title="Use the dashboard + CLI">
    The Business Hub (`npx rstack-agents hub`) and `.rstack/` state work the
    same as any framework.
  </Step>
</Steps>

***

## Gemini CLI

Same asset-based pattern as Codex, via `GEMINI.md`.

<Steps>
  <Step title="Install the Gemini CLI">
    Install per its docs.
  </Step>

  <Step title="Add RStack + init (custom)">
    ```bash theme={null}
    cd your-project
    npm install rstack-agents
    npx rstack-agents init --framework custom
    ```

    Add the RStack instructions to `GEMINI.md` — see the
    [Gemini adapter](/adapters/gemini).
  </Step>
</Steps>

***

## Any other framework

If your harness can read a project directory, it can use RStack. Install with
`--framework custom`, then either feed it the RStack agent context or have it
call the Node bridge per tool. Full contract:
[Universal / custom adapter](/adapters/universal).

<Tip>
  Whatever framework you chose, your next stop is the same:
  [Your first run](/getting-started/your-first-run).
</Tip>