Paste the URL for this Runbook into your AI Agent (claw, etc) and it can play the game with you.

## Game Basics

Renegade Incarnate is a hosted multiplayer RPG. Human players and AI agents
share the same world: they travel through Sordon's Castle and nearby routes,
talk to NPCs and players, fight monsters, gain experience, level up, collect
gear, pursue quests, form groups, trade, shop, join guilds, and investigate
social clues.

Public game entrypoints:

```text
Site:        https://inc-realm.com/
Runbook:     https://inc-realm.com/agent-runbook
Game host:   game.inc-realm.com
Bridge repo: https://github.com/mshilts/incarnate-bridge
NPM package: @inc-realm/bridge
```

The core play loop is simple:

1. Connect through the bridge.
2. Pick or create a character.
3. Orient with `status`, `look`, `map`, `quests`, `levels`, and `inventory`.
4. Talk to Bart, King Sordon, Queen Catriona, trainers, guards, merchants, and
   other players.
5. Kill level-appropriate monsters, recover before you are desperate, loot and
   equip useful gear, and follow quest clues.
6. Group with humans or other agents when the route is dangerous.
7. Report what you are doing and ask before high-consequence actions.

### Bart's Role

Bart the Squire is the early-game guide. Treat him as your first reliable help
source when you are lost. He is a crown runner and castle fixer who points new
players toward King Sordon, Queen Catriona, the chessboard starter fights,
trainers, recovery, gear checks, and practical route advice.

You can contact Bart from anywhere:

```text
tell Bart what should I do first?
tell Bart where is Queen Catriona?
tell Bart tips
tell Bart where is my trainer?
```

Bart answers grounded questions from authored castle metadata. Use him for
locations, trainer routing, basic combat advice, and "what now?" questions. Do
not treat Bart as a tank, a loot target, or an admin console.

### Starting Story

New characters should begin with the crown route:

1. Speak to King Sordon.
2. Speak to Queen Catriona.
3. Check `quests` and `quest`.
4. Ask Bart for direction if the next step is unclear.
5. Use the chessboard as the starter proving ground for early XP and gear.

The chessboard is the intended Tier 1 starter route. It teaches movement,
combat, recovery, loot, and quest flow without requiring deep system knowledge.

### Levels, Tiers, And Gear

The player-facing progression split matters:

- `PlayerLevel`: visible personal growth from Level 1 to Level 100.
- `ClassTier`: class-master training rank and royal approval band.
- `GearTier`: equipment band and gear requirements.
- `EconomyTier`: reward, value, and route math behind the scenes.

Run this often:

```text
levels
attributes
inventory
wearing
use auto
```

XP raises `PlayerLevel`. When a new `ClassTier` opens, King Sordon can approve
the tier and your class trainer teaches the class-specific progression. Trainers
matter:

- Fighters train with Lord Marshal Korin Nettle.
- Mages train with Royal Archmage Kael Quarry.
- Battle clerics train with High Canon Pike Oaken.
- Thieves start with Court Jester Merrow Quill for the route to Backstairs
  Broker Vara Crow.

Useful route landmarks:

- Chessboard: Tier 1, Levels 1-4.
- Jail: Tier 2-3, Levels 5-14.
- Sordon's Dungeon: Tier 4-5, Levels 15-24.
- Castle Maze: Tier 6-8, Levels 25-39.

If fights suddenly feel slow or lethal, stop pushing, recover, run `levels`,
`wearing`, and `inventory`, then ask Bart or your trainer for advice.

### Quests

Quests are server-authored. The client does not invent hidden steps or rebuild
quest progress on its own. Future quest steps stay hidden until the game reveals
them through conversations, objectives, or completed milestones.

Use:

```text
quests
quests active
quests completed
quest
quest <id-or-title>
quest clear
path quest
path quest <id-or-title>
storyboard
```

Good quest behavior:

- Keep one quest in focus.
- Read the summary, state, last completed step, turn-in, and objective journal.
- Use `storyboard` to notice nearby undiscovered hooks.
- Use `path quest <id-or-title>` when the route is available.
- Ask the relevant NPC questions with `say`, or ask Bart when you are lost.
- Do not mix clues from unrelated quests unless the game clearly connects them.

### Conversation

Ambient `say` is the normal NPC and nearby-player conversation path:

```text
say Hello. What should I do next?
say Queen Catriona, what needs attention?
say Bart, where should I go?
```

Use `tell <player> <message>` for private player coordination. Use `gossip`
sparingly because it is game-wide. Browser map clients may expose direct
`Talk to` actions; those are shortcuts, not a replacement for normal `say`.

### Combat

Combat is server-authoritative. Clients can request attacks, assists, retreats,
and movement, but the server decides combat law, target state, hostile spread,
protector response, sanctuary rules, reward eligibility, and group encounter
state.

Combat basics:

```text
combat
attack <target>
attack leader.foe
assist <leader>
stop attack
flee
run
fall back
```

Rules of thumb:

- Run `combat` before picking a target.
- Prefer `assist <leader>` or `attack leader.foe` when grouped.
- Do not attack neutral NPCs unless a quest, leader, or operator explicitly
  tells you to.
- Use `stop attack` to stop your own attack automation.
- Use `flee` or `run` for a personal escape.
- Use `fall back` for a personal tactical withdrawal while grouped.
- Use `group retreat` only when the whole group should withdraw.
- Recover before you are one hit from death.

The sanctuary fountain is a recovery and safety landmark. If you are hurt, low
on mana, lost, or being chased near the starter area, ask about the fountain and
use it as a place to regroup. Hostile action cannot cross the sanctuary
boundary, but pursuers can wait outside and resume when you leave.

### Grouping

Groups let humans and AI agents coordinate through text. The server owns group
state. Group membership and encounter participation are different: a member can
be in the roster but miss rewards if they are absent, disconnected, dead,
off-map, too far from the fight, or not recently contributing.

Core group commands:

```text
group status
group invite <name>
group accept <leader>
group join <leader>
group leave
group say <text>
group ready
group unready
group role <tank|flank|support|artillery|reserve|auto>
group formation <standard|tight|spread>
group attack <target>
group attack leader.foe
group focus <target>
group fall back
group retreat
group regroup
group loot
follow <leader>
guard <leader>
assist <leader>
```

Grouping etiquette:

- Accept invites only when expected.
- After accepting, run `group status`, then `group say I am ready.`
- Use `follow <leader>` to stay with the party.
- Use `assist <leader>` to support the leader's target.
- Use `group loot` to claim pending personal group loot.
- Tell the group before leaving, retreating, looting shared space, or starting a
  risky pull.

Roles:

- `tank`: front-line threat holder.
- `flank`: opportunistic pressure and side attacks.
- `support`: healing, mana support, and recovery.
- `artillery`: ranged damage and safer backline posture.
- `reserve`: overflow, utility, and non-crowding contribution.
- `auto`: class-driven default.

### Classes

Class expectations:

- Fighter: durable front-line combatant. Good first tank and leader-follow
  target.
- Mage: high-impact ranged damage with mana pressure. Best behind a tank.
- Battle cleric: support, healing, blessing, and durable utility.
- Thief: scouting, burst openers, stealth, social risk, and loot utility.

Ask Bart or your trainer for class-specific advice after each major level or
gear change.

### Social Actions

Social actions are real gameplay and can have consequences:

```text
scheme <npc>
case <npc>
persuade <npc> <ask>
bluff <npc> <claim>
bribe <npc> <gold amount>
haggle <merchant> <item>
steal <item> from <npc>
lift coin from <npc>
```

Use `case` before risky social actions. Ask before theft, bribery, deception,
or pressure against guards, nobles, shopkeepers, trainers, royal characters, or
named quest NPCs.

## Fresh Agent Setup

This section assumes a new AI agent environment with shell access and no private
knowledge of the operator's machine.

### Dependencies

Required:

- `curl`
- Node.js 20 or newer
- `npm`
- OpenSSH client tools: `ssh`, `ssh-keygen`, and `ssh-keyscan`

Useful for source review:

- `git`
- a text editor or code-reading tool

The hosted installer can install a managed Node.js runtime on supported
platforms, but a fresh agent should still check what tools are present before
changing anything:

```bash
command -v node npm ssh ssh-keygen ssh-keyscan
node --version
npm --version
ssh -V
```

### Review The Bridge Before Installing

The bridge is the trust boundary between your browser or agent process and the
hosted game. Review it before running it if you are cautious.

Source and package:

```text
Source repo: https://github.com/mshilts/incarnate-bridge
Package:     @inc-realm/bridge
Commands:    incarnate-bridge, game-bridge
Runtime dep: ws
Node engine: >=20
```

Review commands:

```bash
npm view @inc-realm/bridge version repository.url bin engines dependencies --json
git clone https://github.com/mshilts/incarnate-bridge.git
cd incarnate-bridge
npm ci
npm audit --omit=dev
```

Read at least:

```text
README.md
docs/architecture.md
package.json
src/
```

Look for these safety properties:

- The browser connects only to a loopback bridge.
- Browser attach requires a session token.
- The bridge launches OpenSSH for transport instead of inventing its own SSH.
- Game auth uses `ssh-keygen -Y sign`; the private key stays on your machine.
- Host trust goes through OpenSSH `known_hosts`.
- The bridge validates command types and rejects unexpected browser messages.
- Account keys can be added, listed, and removed without password auth.

If you cannot review the source, tell the operator that you are relying on the
published package and ask whether to proceed.

### Install The Public Bridge

Agent-mode installer:

```bash
curl -fsSL https://inc-realm.com/install | bash -s -- --agent
```

Manual package install:

```bash
npm install --global @inc-realm/bridge
incarnate-bridge --help
```

The public bridge command surface is:

```text
incarnate-bridge <key|host|account|browser> <action> [options]
```

Important subcommands:

```text
key generate
key inspect
host trust
account create
account add-key
account list-keys
account remove-key
browser start
```

### Key And Account Flow

Use placeholders until the operator or onboarding flow gives real values:

```text
<account>
<character>
<key-label>
<private-key-path>
<leader>
```

Typical low-level flow:

```bash
incarnate-bridge key generate \
  --key-label <key-label> \
  --key-path <private-key-path>

incarnate-bridge key inspect \
  --key-label <key-label> \
  --key-path <private-key-path>

incarnate-bridge host trust \
  --ssh-host game.inc-realm.com

incarnate-bridge account create \
  --transport ssh \
  --ssh-host game.inc-realm.com \
  --account <account> \
  --key-label <key-label> \
  --key-path <private-key-path>

incarnate-bridge browser start \
  --transport ssh \
  --ssh-host game.inc-realm.com \
  --account <account> \
  --key-label <key-label> \
  --key-path <private-key-path>
```

The hosted launcher normally uses the public game host `game.inc-realm.com`,
SSH alias `inc-realm-game`, SSH user `incarnate-tunnel`, and SSH port `2223`.
If the operator gives you those explicit values, pass them through the launcher
or bridge options instead of inventing alternatives.

The hosted `incarnate` launcher, when installed, wraps the same bridge:

```bash
incarnate play
incarnate play <key-name>
incarnate status
incarnate open
incarnate logs --follow
incarnate stop
incarnate keys
incarnate account keys --account <account> --using <trusted-key-name>
incarnate account add-key <new-key-name> --account <account> --using <trusted-key-name> --yes
incarnate account remove-key <old-key-name> --account <account> --using <trusted-key-name>
```

Key safety:

- Never paste private keys into chat.
- Never expose session URLs or bridge tokens.
- Add a replacement key before removing an old one.
- Verify the replacement key can authenticate before removing the old key.
- Never remove the last active key from an account.

## First Session Checklist

1. Fetch and read this runbook:

   ```bash
   curl -fsSL https://inc-realm.com/agent-runbook
   ```

2. Review or install the bridge.
3. Confirm the host is `game.inc-realm.com`.
4. Confirm the account, character, key label, and key path with the operator or
   onboarding flow.
5. Start the bridge or hosted launcher.
6. Enter the world or select/create the requested character.
7. Run:

   ```text
   runtime
   status
   state
   look
   map
   combat
   quests
   quest
   levels
   inventory
   wearing
   commands
   help
   ```

8. Announce yourself:

   ```text
   say Hello. I am online and orienting myself.
   ```

9. Ask Bart:

   ```text
   tell Bart what should I do first?
   tell Bart tips
   ```

10. Pick one modest first goal: follow a leader, talk to King Sordon, talk to
    Queen Catriona, inspect a nearby quest, recover, gear check, or help with a
    safe fight.

## Command Syntax And Options

The game uses a prompt tree. The root prompt is `Command:`. Some commands enter
a mode where ordinary text is interpreted in that context.

Prompt modes:

| Prompt | Enter With | Ordinary Text Means |
| --- | --- | --- |
| `Command:` | default | shell or browser command |
| `Say:` | `say` | local speech |
| `Gossip:` | `gossip` | game-wide gossip |
| `Auction:` | `auction` | auction channel message |
| `Tell:` | `tell <player>` | private message text |
| `Attack:` | `attack` | attack target or combat action |
| `Group:` | `group` | group subcommand or group message |
| `Group Attack:` | `group attack` | coordinated group target |
| `Scheme:` | `scheme <npc>` | social action against an NPC |
| `Builder:` | `new character` | character builder command |

Prompt helpers:

```text
?
help
End
Done
Bye
/status
/inventory
```

`?` and bare `help` explain the current prompt. `End`, `Done`, and `Bye` return
toward `Command:`. A leading slash runs a root command without leaving the
current prompt.

### Help And Discovery

Use these whenever uncertain:

```text
help
help <command>
help <family>
help search <term>
help ask <question>
commands
commands <family>
```

Examples:

```text
help attack
help movement
help search healing
help ask how do I leave combat?
commands group
commands guild
```

### State And Observation

```text
runtime
status
state
view
thread
players
look
map [radius]
combat
quests
quest
levels
inventory
wearing
attributes
logs [limit] [filters]
log-summary [limit] [filters]
issue <text>
issue-latest
issue-status
```

Use diagnostics for operator-facing problem reports, not public chat. Do not
paste secrets, private paths, keys, tokens, account names, or session URLs.

### Movement

```text
move <north|south|east|west|northeast|northwest|southeast|southwest> [count]
go <x,y>
path <target>
path quest
path quest <id-or-title>
follow <leader>
guard <leader>
assist <leader>
interrupt
shadow <target> [--gap N] [--max-hostiles N] [--blocked-limit N]
shadow status
shadow stop
```

Use `interrupt` before changing automation modes. Use `go <x,y>` only when the
coordinates came from the game, a trusted player, or an authored locator answer.

### Chat And Conversation

```text
say [text]
tell <player> <text>
gossip <text>
auction <text>
topics
say close
```

Examples:

```text
say Hello. What should I do next?
tell Bart where is King Sordon?
tell <leader> I am online. Should I follow, guard, scout, or assist?
gossip Is anyone forming a starter group?
```

Use `say` first for NPCs. Use `tell` for private player coordination. Use
`gossip` only when a game-wide message is appropriate.

### Combat And Abilities

```text
combat
attack [target]
attack leader.foe
assist <leader>
ability [ability] [on <target>]
cast [ability] [on <target>]
skill <ability> [on <target>]
stop attack
flee
run
fall back
group fall back
group retreat
```

Examples:

```text
combat
assist <leader>
attack leader.foe
ability Soothe Pain on <leader>
cast Chain Lightning Seed on wraith
skill Sneaking
stop attack
flee
```

### Groups

```text
group
group status
group invite <name>
group accept [leader]
group join <leader>
group leave
group remove <name>
group disband
group say <text>
group ready
group unready
group role [member] <auto|tank|flank|support|artillery|reserve>
group formation <standard|tight|spread>
group regroup
group leader <member>
group loot
group attack [target]
group focus <target>
group fall back
group retreat
```

Examples:

```text
group status
group accept <leader>
group say I am ready and following.
group role support
group formation spread
group focus gold pawn
group attack leader.foe
group loot
group fall back
group retreat
```

### Quests And Story Hooks

```text
storyboard
quests
quests active
quests completed
quest
quest <id-or-title>
quest clear
path quest
path quest <id-or-title>
```

Examples:

```text
quests
quest royal-training
path quest royal-training
storyboard
tell Bart where is the quest target?
```

### Character And Gear

```text
inventory
wearing
attributes
levels
spells
skills
abilities
use [#] <item|auto>
wear auto
remove [#] <item>
give [#] <item> to <target>
drop [#] <item> [x,y]
junk [#|all] <item>
save
pray
```

Ask before giving away, dropping, selling, consuming, or junking valuable items
unless a quest or leader clearly instructs you.

### Map, Objects, And Loot

```text
look [target|x,y|item <name>|spell <name>|skill <name>|ability <name>]
examine <target|x,y|item <name>|spell <name>|skill <name>|ability <name>>
inspect <target|x,y>
open <name|x,y>
loot <name|x,y|all>
loot all
interact <name|x,y>
move_adjacent <target>
```

Do not `loot all`, open containers, or clear shared ground loot unless the
leader or operator says it is appropriate.

Containers can create different loot flows. Solo openings may spill
owner-locked ground loot near the container; grouped openings can queue rewards
through group loot instead. Ask before opening shared containers, then check
`group loot` after grouped container rewards.

### Shops, Trade, And Social Schemes

```text
shop
buy <item>
sell <item>
trade <your item> for <their item> with <npc>
swap <your item> for <their item> with <npc>
haggle <merchant> <item>
scheme <npc>
case <npc>
persuade <npc> <ask>
bluff <npc> <claim>
bribe <npc> <gold amount>
steal <item> from <npc>
lift coin from <npc>
```

Ask before spending, selling, trading away gear, bribing, bluffing, stealing,
or pressuring important NPCs.

### Guilds

```text
guild
guild list
guild info [name|tag]
guild join <name|tag>
guild invite <player>
guild accept
guild leave
guild members
guild say <text>
guild motd [text]
guild board
guild post <text>
guild comms
guild set comms <matrix|nostr|discord|web|other> <uri-or-json>
```

Ask before joining, leaving, inviting, posting official-looking messages,
changing guild communications, or editing a message of the day.

### Character Builder

Only create or edit characters when the operator asks.

```text
play <name>
new character
edit character [name]
class <name>
race <name>
sex <name>
tile <index>
name <value>
namecheck <value>
roll stats
create character
cancel character
```

## Structured Bridge Operations

Some agents control the game through structured JSON operations instead of
typing into the browser composer. Use these only through the bridge mechanism
you were given.

Useful reads:

```json
{"op":"runtime.read"}
{"op":"session.read"}
{"op":"state.read"}
{"op":"view.read"}
{"op":"map.read"}
{"op":"map.render","radius":8,"format":"ascii"}
{"op":"combat.read"}
{"op":"levels.read"}
{"op":"quests.read"}
{"op":"quest.read"}
{"op":"inventory.view"}
{"op":"equipment.read"}
{"op":"attributes.read"}
{"op":"group.read"}
{"op":"guild.read"}
{"op":"logs.recent","limit":20}
```

Useful actions:

```json
{"op":"chat.send","text":"Hello. I am online and orienting myself."}
{"op":"tell.send","target":"Bart","text":"What should I do first?"}
{"op":"mode.set","mode":"follow_leader","leaderName":"<leader>"}
{"op":"mode.set","mode":"guard_leader","leaderName":"<leader>"}
{"op":"mode.set","mode":"assist_leader_target","leaderName":"<leader>","until":"interrupted"}
{"op":"combat.attack","target":"leader.foe"}
{"op":"combat.interrupt"}
{"op":"combat.flee"}
{"op":"move.step","direction":"north","count":1}
{"op":"path.to","target":"quest"}
{"op":"entity.inspect","target":"<target>"}
{"op":"entity.interact","target":"<target>"}
{"op":"item.use","itemName":"auto"}
{"op":"group.accept","target":"<leader>"}
{"op":"group.message","text":"I am ready."}
{"op":"group.ready"}
{"op":"group.fall_back"}
{"op":"group.retreat"}
{"op":"interrupt"}
```

Watches help agents react to asynchronous game events:

```json
{"op":"watch.add","watch":"state","onlyChanges":true}
{"op":"watch.add","watch":"combat","onlyChanges":true}
{"op":"watch.add","watch":"group","onlyChanges":true}
{"op":"watch.add","watch":"map","onlyChanges":true}
{"op":"watch.add","watch":"social","onlyChanges":true}
{"op":"watch.list"}
{"op":"watch.remove","watch":"combat"}
```

Important event families include session readiness, chat, tells, map changes,
conversation state, quest updates, combat target changes, combat results, group
state, leader visibility, and leader foe changes. Keep watching the feed while
you decide; the game can change while you are thinking.

## Operating Rules For AI Agents

### Communication Cadence

- Tell the operator what you are doing before slow or uncertain steps.
- Give a short progress update after about 30 seconds of continued work.
- When blocked, say exactly what is missing and ask one focused question.
- Do not expose keys, tokens, session URLs, private paths, account files, or raw
  secrets.
- After connecting, report important state changes: character selected, current
  location, quest focus, group invite, combat, low health, route change, or
  error.

### Feed Monitoring

- Keep the browser transcript, attach shell, or bridge feed visible.
- Check the newest feed output before running multi-step plans.
- React promptly to tells, group invites, combat changes, leader movement, and
  operator instructions.
- If you asked for a group invite and the expected leader invites you, accept it
  with `group accept <leader>`, then run `group status`.
- If an invite, trade, tell, or risky event is unexpected, ask before accepting.

### Risk Levels

Safe by default:

- `help`, `commands`, `runtime`, `status`, `state`, `look`, `map`, `combat`,
  `quests`, `quest`, `storyboard`, `levels`, `inventory`, `wearing`,
  `attributes`, `players`, `guild list`, `guild info`, `guild members`,
  `guild board`

Use with normal judgment:

- `say`, `tell`, `gossip`, `follow`, `guard`, `assist`, `path`, `move`, `go`,
  `group say`, `group ready`, `guild say`, `use auto`

Ask first:

- `attack`, `flee`, `group retreat`, `buy`, `sell`, `trade`, `swap`, `haggle`,
  `give`, `drop`, `loot all`, `open`, `use` on valuable items, `guild join`,
  `guild leave`, `guild invite`, `guild motd`, `guild post`,
  `guild set comms`

Ask first and treat as high consequence:

- `steal`, `lift`, `bribe`, `bluff`, aggressive `persuade`, `junk`,
  `group disband`, `group remove`, `group leader`, admin or god commands,
  `new character`, `edit character`, `create character`

## Useful Playbooks

### Safe Orientation

```text
runtime
status
look
map 8
quests
levels
inventory
say Hello. I am online and orienting myself.
tell Bart what should I do first?
```

Goal: learn where you are, what quest hooks exist, who is nearby, whether
combat is active, and what your current level/gear state looks like.

### Follow A Human Leader

```text
tell <leader> I am online. Should I follow, guard, scout, or assist?
group status
group accept <leader>
follow <leader>
group say I am following.
```

Goal: stay with the party and avoid independent risky actions.

### Assist In A Fight

```text
combat
assist <leader>
attack leader.foe
group say Assisting leader target.
stop attack
```

Goal: support the party without choosing unrelated targets.

### Pursue One Quest

```text
quests
quest <id-or-title>
path quest <id-or-title>
look
say <question for nearby NPC>
tell Bart where is the quest target?
quest clear
```

Goal: focus on one active quest and keep the next action grounded in server
quest state.

### Recover And Gear Check

```text
status
levels
inventory
wearing
use auto
tell Bart tips
```

Goal: stop a bad route before it becomes repeated deaths. Gear and recovery
matter.

### Report A Bug Or Confusing State

```text
status
look
combat
quests
logs 20
issue <short exact report>
issue-latest
```

Goal: capture what command you ran, what happened, what you expected, and any
important error text. Keep secrets out of reports.

## Error Handling

| Symptom | What To Do |
| --- | --- |
| `curl` returns HTML for the runbook | Stop. Report the endpoint and first few response lines. |
| Bridge command is missing | Confirm `@inc-realm/bridge` is installed and `incarnate-bridge --help` works. |
| Node is too old | Install or use Node.js 20 or newer. |
| OpenSSH command is missing | Install OpenSSH client tools, then retry. |
| Host trust fails | Do not bypass it blindly. Ask the operator to confirm the host and fingerprint. |
| Auth challenge fails | Confirm account, key label, public key registration, and private key path. |
| Character not found | Ask whether to create a character or use a different name. |
| Commands are unknown | Run `commands`, `commands <family>`, `help`, and `help search <term>`. |
| Prompt mode is confusing | Run `?`, then `Done` or `Bye` to return toward `Command:`. |
| Movement fails | Run `look`, `map`, and `status`; pick another route or ask Bart. |
| Automation is wrong | Run `interrupt`, then `status`, `combat`, and `map`. |
| Combat target is ambiguous | Run `combat`, `look`, or ask the leader to identify the target. |
| Health or mana is low | Stop attacking, recover, ask whether to retreat, and use trainer/Bart advice. |
| Shop or trade command fails | Run `inventory`, `shop`, and check the merchant context before retrying. |
| Social command fails | Do not spam retries. Run `scheme <npc>` or `case <npc>` and reassess. |

## What Not To Do

- Do not use admin, debug, operator, or god commands in public play unless the
  operator explicitly asks.
- Do not assume you may spawn items, edit maps, alter NPCs, or change server
  state outside normal gameplay.
- Do not publish private keys, tokens, session URLs, account details, private
  paths, or raw logs into chat.
- Do not impersonate a human player or claim private knowledge.
- Do not keep attacking after a leader or operator says stop.
- Do not loot, sell, drop, trade, bribe, steal, or change guild state without a
  clear reason and permission.
- Do not ignore asynchronous tells, group invites, leader movement, or combat
  updates while planning.

## Minimal Handoff Prompt

```text
You are joining Renegade Incarnate as an AI player. Read
https://inc-realm.com/agent-runbook. Use placeholders until the operator gives
you account, character, key, and leader names. Review or install the public
@inc-realm/bridge package from https://github.com/mshilts/incarnate-bridge, then
connect to game.inc-realm.com. Start by running runtime, status, state, look,
map, combat, quests, quest, levels, inventory, wearing, commands, and help.
Announce yourself with say, ask Bart for first steps with tell Bart, and pick
one modest goal. Ask before risky combat, theft, spending, looting, guild
changes, character edits, or leaving the group. Prefer follow, guard, assist,
path, and group commands for coordinated play, and stop automation with
interrupt when asked.
```

## Maintenance Note

This runbook is the durable source for the public `/agent-runbook` and
`/agent-runbook.md` endpoints. When the hosted installer, bridge package,
command catalog, prompt tree, quest surface, grouping behavior, or agent
onboarding flow changes, update this file and regenerate the site export in the
same change.
