clawhub

structs-guild

Item: structs-guild
Rating: 8.3
Author: Implexa

Guilds in Structs — choosing and joining one, ranks and rank-permissions, membership flows, settings, UGC moderation, charter vs entitlement founding, and the Central Bank (mint/redeem/convert). Use when picking a guild to join, creating a guild, managing members or ranks, moderating member identity, or running guild token operations.

view source

installs

1,237

stars

karma

SkillRank score ↗

8.3/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-07-10

structs-guild manages creation, membership flows, rank-based authority, central bank token operations, and decentralized ugc moderation for guild communities. covers permission models, error conditions, and audit trails for sensitive operations.

structure

9.0

trigger phrases

9.0

procedure

9.0

edge cases

7.0

documentation

8.0

strengths

view original SKILL.md from clawhubclick to expand

---
title: "Guild skill: join, ranks, Central Bank"
meta_description: A guild gives you a reactor, a substation, a market, a token, and allies. Choosing one, joining, ranks, membership, and UGC moderation.
name: structs-guild
description: Guilds in Structs — choosing and joining one, ranks and rank-permissions, membership flows, settings, UGC moderation, charter vs entitlement founding, and the Central Bank (mint/redeem/convert). Use when picking a guild to join, creating a guild, managing members or ranks, moderating member identity, or running guild token operations.
level: core
domain: social
---

# Guild skill: join, ranks, Central Bank

A guild is your faction: it gives you a reactor to infuse, a substation to draw power from, a market to sell into, a token to mint, and allies (or moderators). For a new player, **which guild you join is one of your most consequential early choices** — it shapes your power source, your economy, and who has your back. This skill covers choosing/joining, running a guild, ranks/permissions, identity moderation, and the Central Bank.

Conventions (TX_FLAGS, `--` rule, charge bar, one-tx-at-a-time) are in [`conventions.md`](https://structs.ai/skills/conventions).

## When to use it

- New player deciding which guild to join (or whether to go solo).
- Creating or administering a guild.
- Managing members, ranks, or moderating member identity.
- Minting/redeeming guild tokens or managing Central Bank collateral.

## Decisions

**Choosing a guild (beginner)** — evaluate candidates on:
- **Reactor commission** — lower = more capacity per gram you infuse (`structsd query structs reactor [id]`).
- **Join requirements** — `joinInfusionMinimum` you must meet (or get an invite to bypass).
- **Activity & size** — `guild-all` then inspect members; an active guild means a working market and defenders.
- **Token economy** — a guild whose token is actually used (providers priced in it) makes your earnings liquid.
- **Politics** — see [`knowledge/lore/factions`](https://structs.ai/knowledge/lore/factions) and your standing-orders. Joining a guild at war inherits its enemies.

A guild is rarely a trap, but its moderators gain reach into your name/pfp while you're a member (see UGC below). If you dislike a policy, you can leave.

**Creating a guild (advanced)** is either the **chain-global charter PoW** (`guild-create-compute`, weeks for a lone miner) or a **one-time reactor entitlement** (`guild-create` without proof: bonded validator past ~30 days, `PermReactorGuildCreate` on the reactor). A founder who **owns** a guild must transfer it first. Founding leaves your current guild if you are only a member. Third-party solvers need `guild-charter-consent`. See [hashing.md — Guild Charter](https://structs.ai/knowledge/mechanics/hashing#guild-charter).

## Rank system

Numeric ranks, **lower number = higher privilege**:

| Rank | Meaning |
|------|---------|
| 1 | Maximum (guild creator) |
| 2–100 | Custom ranks assigned by leadership |
| 101 | Default on join |
| 0 | Unset |

A player can only modify members whose rank is strictly **worse** (higher number) than their own. Rank-permissions (granting a permission to everyone at/above a rank) are the scalable way to delegate — see [`structs-permissions`](https://structs.ai/skills/structs-permissions/SKILL).

## Procedure

### Join

1. Discover: `structsd query structs guild-all`, then `guild [id]` and `reactor [id]` for the candidates.
2. Meet the infusion minimum (or secure an invite). Join:
   ```
   structsd tx structs guild-membership-join TX_FLAGS -- [guild-id] [infusion-id,...]
   ```
   You get the default entry rank (101). Flows: **invite** (`guild-membership-invite` → invitee `...-invite-approve`/`-deny`), **request** (`guild-membership-request` → owner `...-request-approve`/`-deny`), **proxy** (a guild signs you in: `guild-membership-join-proxy -- [address] [proof-pubkey] [proof-signature]`, with optional `--substation-id`, `--player-name`, `--player-pfp`, `--player-pfp-client-render-attributes`).

### Administer

- **Ranks**: `player-update-guild-rank TX_FLAGS -- [player-id] [rank]` (needs PermAdmin or rank authority); `guild-update-entry-rank TX_FLAGS -- [rank]` (new rank ≥ your own).
- **Membership**: `guild-membership-kick -- [player-id]` (the guild is implicit in the target player); invite/request approve/deny/revoke as above.
- **Settings**: `guild-update-endpoint`, `guild-update-entry-substation-id`, `guild-update-join-infusion-minimum` (+ `-by-invite`/`-by-request`; unknown bypass-level values are denied), `guild-update-owner-id` (Tier 2 — transfers the guild). Invite/request **approve** and **accept** require a pending application — they do not create one.
- **Founding**: entitlement `guild-create -- [reactor-id] [endpoint] [entry-substation-id]` or charter `guild-create-compute -D 3` (query `guild-charter` first). Third-party solver: `guild-charter-consent` then proof-path create.

### UGC moderation

Structs has no global moderator — each guild sets its own name/pfp standards for member-owned objects, and the chain emits an audit event on every override. Grant moderation by rank (recommended) or per player:

```bash
# Members at rank 5 or better can moderate guild-mate UGC
structsd tx structs permission-guild-rank-set TX_FLAGS -- [guild-id] [guild-id] 16777216 5
# Or a single moderator on the guild object
structsd tx structs permission-grant-on-object TX_FLAGS -- [guild-id] [moderator-player-id] 16777216
```

Perform a moderation: `player-update-name`/`player-update-pfp`/`planet-update-name`/`substation-update-name`/`substation-update-pfp TX_FLAGS -- [target-id] "value"`. When the actor isn't the owner, the chain emits `ugc_moderated` (actor, target, field, old/new) — audit it. Note `pfpClientRenderAttributes` is **owner-only** and **not** guild-moderatable. Full philosophy + validation: [`knowledge/mechanics/ugc-moderation`](https://structs.ai/knowledge/mechanics/ugc-moderation).

### Central Bank (mint / redeem / convert)

- **Mint** tokens against Alpha collateral: `guild-bank-mint TX_FLAGS -- [alpha-amount] [token-amount]` (signer's guild implicit; raw integers; ratio captured at action time). Guild-privileged.
- **Redeem** tokens for Alpha: `guild-bank-redeem TX_FLAGS -- [amount]uguild.[guild-id] [min-amount-alpha]` — coin string plus Alpha slippage floor. Payout is `floor(amount * collateral / supply)` but still rejected if that payout is below `min-amount-alpha`.
- **Convert** ualpha into an existing guild token at the live collateral ratio: `guild-bank-convert TX_FLAGS -- [guild-id] [alpha-amount] [min-amount-token]`. Needs `PermTokenTransfer` on the signer. Convert-in fee stays in collateral. `min-amount-token` is the slippage floor.
- **Convert token → token**: `guild-bank-convert-token TX_FLAGS -- [amount]uguild.[source-id] [target-guild-id] [min-amount-token]` — redeems the source then converts into the target in one tx; both guilds keep their fees.
- **Confiscate & burn** (Tier 2 act of war, audited forever): `guild-bank-confiscate-and-burn TX_FLAGS -- [amount]uguild.[guild-id] [address]` — token amount first, then the address it is taken from. The destination of a `uguild.*` send must be a registered player, the structs module, or an indexed provider pool — **not IBC**.

Mint/redeem are Tier 1 within your standing-order caps, Tier 2 above. Convert is the open market path. Economics: [`knowledge/economy/guild-banking`](https://structs.ai/knowledge/economy/guild-banking).

## Commands reference

| Action | Command |
|--------|---------|
| Create (entitlement) | `structsd tx structs guild-create TX_FLAGS -- [reactor-id] [endpoint] [entry-substation-id]` |
| Create (charter PoW) | `structsd tx structs guild-create-compute -D 3 TX_FLAGS_APPROVED -- [reactor-id]` |
| Charter query / consent | `structsd query structs guild-charter` / `structsd tx structs guild-charter-consent TX_FLAGS -- [reactor-id]` (offline signature; not broadcast) |
| Join / proxy | `structsd tx structs guild-membership-join \| guild-membership-join-proxy TX_FLAGS -- ...` |
| Invite / request (+approve/deny/revoke) | `structsd tx structs guild-membership-invite \| -request \| ...-approve \| ...-deny TX_FLAGS -- ...` |
| Kick | `structsd tx structs guild-membership-kick TX_FLAGS -- [player-id]` |
| Update rank / entry rank | `structsd tx structs player-update-guild-rank \| guild-update-entry-rank TX_FLAGS -- ...` |
| Settings | `structsd tx structs guild-update-endpoint \| -entry-substation-id \| -join-infusion-minimum \| -owner-id TX_FLAGS -- ...` |
| Guild UGC | `structsd tx structs guild-update-name \| guild-update-pfp TX_FLAGS -- [guild-id] [value]` |
| Moderate member/object | `structsd tx structs player-update-name \| ...-pfp \| planet-update-name \| substation-update-name \| -pfp TX_FLAGS -- [target-id] [value]` |
| Bank mint / redeem / convert / confiscate | `structsd tx structs guild-bank-mint \| guild-bank-redeem \| guild-bank-convert \| guild-bank-convert-token \| guild-bank-confiscate-and-burn TX_FLAGS -- ...` |
| Guild rank permission set/revoke | `structsd tx structs permission-guild-rank-set \| permission-guild-rank-revoke TX_FLAGS -- [object-id] [guild-id] [permission] [rank]` |

`TX_FLAGS` per [`conventions.md`](https://structs.ai/skills/conventions). **Requires** [`structsd`](https://structs.ai/skills/structsd-install/SKILL) on PATH and a signing key.

## Verification

- `structsd query structs guild [id]` — members, settings, owner.
- `structsd query structs guild-charter` — global charter anchor and difficulty.
- `guild-membership-application-all` — pending invites/requests.
- `guild-bank-collateral-address [guild-id]` — reserves.
- `guild-rank-permission-by-object-and-guild [object-id] [guild-id]` — rank-based access.

## Errors

- **Insufficient infusion** — meet `joinInfusionMinimum` or get an invite (bypasses it).
- **is_owner** — you own a guild; transfer it before founding another.
- **under_raid** — not a guild error; see production.
- **Already member** — founding leaves your current guild if you are only a member; you cannot join twice.
- **Invite/request approve with no pending application** — membership approval requires an existing application.
- **Mint/redeem/convert failed** — insufficient Alpha/tokens, or `min-amount-token` slippage missed.
- **recipient_not_eligible** — `uguild.*` cannot go to IBC escrow or an unregistered address.
- **Permission denied / rank too low** — need PermAdmin or strictly-better rank; entry rank can't exceed your own.

## See also

- [knowledge/economy/guild-banking](https://structs.ai/knowledge/economy/guild-banking) — Central Bank, collateral, token lifecycle
- [knowledge/mechanics/permissions](https://structs.ai/knowledge/mechanics/permissions) — 25-bit values, guild rank permissions
- [knowledge/mechanics/ugc-moderation](https://structs.ai/knowledge/mechanics/ugc-moderation) — name/pfp moderation & validation
- [knowledge/lore/factions](https://structs.ai/knowledge/lore/factions) — guild politics
- [playbooks/situations/guild-war](https://structs.ai/playbooks/situations/guild-war) — coordinated conflict; [structs-permissions](https://structs.ai/skills/structs-permissions/SKILL) — delegating authority

don't have the plugin yet? install it then click "run inline in claude" again.

Structs Guild

intent

this skill manages the full lifecycle of guilds in structs, from creation through membership coordination to central bank token operations. use it when you need to create a guild, join or leave one, adjust guild settings, handle rank-based permissions, moderate member identities, or mint/redeem guild tokens backed by alpha matter collateral. the skill handles both direct operations (you acting as guild owner or rank-holder) and decentralized moderation patterns where guild ranks control who can modify member names and profile pictures.

inputs

structsd CLI

requires structsd binary on PATH with a configured signing key
install via structsd-install skill

signing key

a named key accessible via --from [key-name] flag
required for all transaction commands

guild identifiers

guild-id: numeric identifier returned by guild-create or discovered via guild-all query
reactor-id, entry-substation-id: required at guild creation
guild rank system: numeric ranks where 1 is max privilege (creator), 2-100 are custom ranks, 101 is default entry rank, 0 is unset

guild permissions (25-bit values)

PermAdmin (2): broad guild control
PermUpdate (4): rename/update guild settings
PermGuildUGCUpdate (16777216): moderate member names and pfps
PermReactorGuildCreate (524288): required on reactor to create guild
PermSubstationConnection (1024): required on entry substation to create guild
PermProviderAgreementCreate (262144): access provider services
PermReactorGuildCreate (524288): create guilds on reactor

external dependencies

structs blockchain (on-chain guild state, rank system, permission audit trail)
alpha matter collateral pool (for guild bank mint/redeem operations)

edge cases to handle

entity ids with dashes (e.g. 3-1, 4-5) are misparsed as flags; all transaction commands use -- separator before positional args
network timeouts during blockchain queries or submissions
permission checks happen post-submission; insufficient permissions fail at chain level
rank authority: actor can only modify members with strictly worse (higher) rank numbers
guild bank collateral depletes on mint, requires sufficient alpha matter reserves
member removal via kick instantly revokes all rank-based permissions

procedure

discover existing guilds (optional setup step)
- input: none (queries run against chain state)
- run structsd query structs guild-all to list all guilds or structsd query structs guild [id] to inspect one guild
- output: guild metadata including owner, members, ranks, settings, central bank address
- decision: proceed to create if no guild exists, or join if guild already live
create guild
- input: reactor-id (numeric), endpoint (string url), entry-substation-id (numeric)
- requires PermReactorGuildCreate (524288) on the reactor and PermSubstationConnection (1024) on entry substation
- run structsd tx structs guild-create --from [key-name] --gas auto --gas-adjustment 1.5 -- [reactor-id] [endpoint] [entry-substation-id]
- output: guild-id assigned by chain; creator receives rank 1; entry-rank defaults to 101
- safety: verify reactor and substation permissions before submission; confirm endpoint is correct
join guild (direct flow)
- input: guild-id (numeric), infusion-ids (comma-separated list)
- check guild's joinInfusionMinimum via structsd query structs guild [guild-id]; provide sufficient infusions or request an invite instead
- run structsd tx structs guild-membership-join --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [infusion-id,infusion-id2,...]
- optional flags: --player-id [id], --substation-id [id] if joining on behalf of another entity
- output: membership record created; joining player receives default rank (101); no rank-based permissions until manually assigned
- decision: if infusion minimum not met, use invite or request flow instead
join guild (proxy flow)
- input: address (player address), proof-pubkey (signing pubkey), proof-signature (signed proof), optional substation-id, player-name, player-pfp
- this flow allows a guild to sign in a new player without waiting for direct action
- run structsd tx structs guild-membership-join-proxy --from [key-name] --gas auto --gas-adjustment 1.5 [--substation-id sub] [--player-name name] [--player-pfp pfp] -- [address] [proof-pubkey] [proof-signature]
- output: new membership created with optional UGC fields seeded on-chain
- safety: verify proof-signature cryptographically before submitting; this bypasses infusion minimums
join guild (invite flow)
- input: guild-id, player-id (invitee)
- guild owner runs structsd tx structs guild-membership-invite --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [player-id]
- invitee receives invitation; invitee then runs either:
  - structsd tx structs guild-membership-invite-approve --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] (accept)
  - structsd tx structs guild-membership-invite-deny --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] (decline)
- owner can revoke via structsd tx structs guild-membership-invite-revoke --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [player-id]
- output: membership created on approval; no membership on denial
- edge case: invitations expire or become stale if guild settings change; reissue if needed
join guild (request flow)
- input: guild-id (requester initiates)
- requester runs structsd tx structs guild-membership-request --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id]
- guild owner then runs either:
  - structsd tx structs guild-membership-request-approve --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [player-id] (approve)
  - structsd tx structs guild-membership-request-deny --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [player-id] (deny)
- owner can revoke via structsd tx structs guild-membership-request-revoke --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id]
- output: membership created on approval; no membership on denial
- edge case: multiple pending requests queue; owner must action each individually
manage member ranks
- input: player-id, target guild-rank (numeric 1-101+)
- requires either PermAdmin (2) on guild or rank-based authority (actor's rank strictly better than target's current rank)
- run structsd tx structs player-update-guild-rank --from [key-name] --gas auto --gas-adjustment 1.5 -- [player-id] [guild-rank]
- output: player's rank updated; permissions held by that rank are immediately active or revoked depending on new rank
- decision: actor rank must be < target rank (numerically lower). creator (rank 1) can assign any rank
- edge case: cannot demote or promote players with rank better than your own; revoke by removing membership if needed
update guild entry rank
- input: new-entry-rank (numeric, typically 101 or higher)
- requires PermUpdate (4) on guild; new rank must be >= caller's own rank
- run structsd tx structs guild-update-entry-rank --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [new-entry-rank]
- output: future joiners receive new-entry-rank; existing members' ranks unchanged
- decision: if new rank is lower (more privileged), you must have that privilege level yourself
update guild settings
- input depends on setting type; all use -- before positional args
- endpoint: structsd tx structs guild-update-endpoint --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [endpoint]
- entry substation: structsd tx structs guild-update-entry-substation-id --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [substation-id]
- infusion minimums: structsd tx structs guild-update-join-infusion-minimum --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [value], or -minimum-by-invite, -minimum-by-request variants
- owner: structsd tx structs guild-update-owner-id --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [new-owner-player-id]
- output: setting immediately takes effect; affects future joins and operations
- safety: owner transfer is permanent; verify new owner's player-id before submission (tier 2 risk)
update guild identity (UGC)
- input: guild-id, name (string) or pfp (url/ipfs hash)
- requires PermUpdate (4) on guild
- update name: structsd tx structs guild-update-name --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [name]
- update pfp: structsd tx structs guild-update-pfp --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [pfp]
- output: new name/pfp on-chain immediately; emits ugc_moderated event if updater is not owner
- validation: names and pfps are first-class on-chain UGC fields subject to strict per-field validation rules (see knowledge/mechanics/ugc-moderation)
grant moderation permissions (per-rank pattern)
- input: guild-id, target-rank (numeric)
- use this to allow members at a specific rank or better to moderate guild-mates' names and pfps
- run structsd tx structs permission-guild-rank-set --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [guild-id] 16777216 [target-rank]
- output: all members at rank <= target-rank now have PermGuildUGCUpdate (16777216); can modify names/pfps of guild-mates
- decision: lower number = higher privilege, so rank 5 allows more people to moderate than rank 2
grant moderation permissions (per-player pattern)
- input: guild-id, moderator-player-id
- use this to grant moderation power to a single player only
- run structsd tx structs permission-grant-on-object --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [moderator-player-id] 16777216
- output: only the specified player can moderate guild-mates; rank-independent
- decision: use when you want granular control over who moderates
perform moderation action (player name)
- input: target-player-id, new-name (string)
- requires PermGuildUCGUpdate (16777216) on guild; must be rank-based or per-player grant
- run structsd tx structs player-update-name --from [key-name] --gas auto --gas-adjustment 1.5 -- [target-player-id] "NewSafeName"
- output: player's name changed on-chain; if you are not the player's owner, a ugc_moderated event is emitted with actor, target, old/new values
- safety: tier 1 when acting on own player, tier 1 (audited) when moderating others (permanent record)
- validation: name must satisfy per-field rules in knowledge/mechanics/ugc-moderation
perform moderation action (player pfp)
- input: target-player-id, pfp-url (https:// or ipfs://)
- requires PermGuildUCGUpdate (16777216) on guild
- run structsd tx structs player-update-pfp --from [key-name] --gas auto --gas-adjustment 1.5 -- [target-player-id] "ipfs://<cid>"
- output: player's pfp changed on-chain; ugc_moderated event emitted if you are not the owner
- validation: pfp url must pass format validation
perform moderation action (planet or substation name/pfp)
- input: planet-id or substation-id, new-name or new-pfp
- requires PermGuildUCGUpdate on the planet or substation (not the guild)
- planet name: structsd tx structs planet-update-name --from [key-name] --gas auto --gas-adjustment 1.5 -- [planet-id] "NewPlanetName"
- substation name: structsd tx structs substation-update-name --from [key-name] --gas auto --gas-adjustment 1.5 -- [substation-id] "NewSubName"
- substation pfp: structsd tx structs substation-update-pfp --from [key-name] --gas auto --gas-adjustment 1.5 -- [substation-id] "https://..."
- output: object identity changed on-chain; ugc_moderated event emitted if you are not the owner
- safety: tier 1 (audited); permanent record of all moderation actions
grant provider access via guild rank
- input: provider-id, guild-id, minimum-rank (numeric)
- use this to restrict provider services to guild members above a certain rank
- run structsd tx structs permission-guild-rank-set --from [key-name] --gas auto -- [provider-id] [guild-id] 262144 [rank]
- this grants PermProviderAgreementCreate (262144) on the provider to any member of guild-id at rank <= [rank]
- output: provider-guild linkage created; members meeting rank threshold can now access provider
- to revoke: structsd tx structs permission-guild-rank-revoke --from [key-name] --gas auto -- [provider-id] [guild-id] 262144
mint guild tokens (central bank)
- input: alpha-amount (raw integer, atomic units), token-amount (raw integer, atomic units)
- requires ownership or delegation of guild's central bank; guild is determined implicitly from signer
- run structsd tx structs guild-bank-mint --from [key-name] --gas auto --gas-adjustment 1.5 -- [alpha-amount] [token-amount]
- output: alpha-amount locked in guild's collateral pool; token-amount minted and distributed to signer
- decision: decide collateral ratio upfront (alpha-amount / token-amount); ratio is captured at action time and drives guild token value
- safety: tier 1 within standing-order caps, tier 2 above; surface alpha amount, token amount, and resulting collateral ratio before submission
- edge case: insufficient alpha matter in guild's reserves fails with "insufficient collateral" error; verify via query before attempting
redeem guild tokens (central bank)
- input: guild-id, token-amount (raw integer)
- requires ownership or delegation; redeems tokens and unlocks collateral
- run structsd tx structs guild-bank-redeem --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [token-amount]
- output: token-amount burned; corresponding alpha matter returned from collateral pool
- edge case: insufficient tokens held by redeemer fails with "insufficient token balance" error; check balance before submission
confiscate and burn guild tokens (central bank)
- input: guild-id, address (player address), amount (raw integer)
- this is a tier 2 operation (act of war); confiscates tokens from a guild member and burns them
- requires PermAdmin on guild or guild ownership
- run structsd tx structs guild-bank-confiscate-and-burn --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [address] [amount]
- output: tokens removed from target address; burned permanently; collateral ratio increases; chain emits permanent audit record
- safety: tier 2 (rarely the right tool); usually rank revocation is more appropriate; chain audits the burn forever
- decision: only use when you intend permanent exclusion; confiscate-and-burn is more severe than membership kick
kick member from guild
- input: guild-id, player-id
- requires PermAdmin or rank-based authority (actor's rank better than target's)
- run structsd tx structs guild-membership-kick --from [key-name] --gas auto --gas-adjustment 1.5 -- [guild-id] [player-id]
- output: membership record removed; target loses guild rank and all rank-based permissions; no tokens burned (unlike confiscate-and-burn)
- safety: tier 1; kicked