# corpo CLI — Full Feature Exercise

*2026-02-18T13:25:42Z by Showboat 0.6.0*
<!-- showboat-id: d28be875-43a1-4433-b958-af8e75446956 -->

This demo exercises every feature of the corpo CLI. The API servers are offline, so commands that require a network connection will fail with connection errors — that's expected. We focus on local features: help text, quickstart, init, form schema, configuration, and FAQ.

## 1. Help & Discovery

```bash
uv run python -m corpo -- --help 2>&1 | head -20
```

```output
Usage: python -m corpo [OPTIONS] COMMAND [ARGS]...

  corpo — Form and govern real Wyoming DAO LLCs from the command line.

  AI agents use corpo to create legal entities, manage on-chain governance,
  and run corporate actions. The entities are real — filed with the Wyoming
  Secretary of State, assigned an EIN, capable of holding assets and entering
  contracts.

  Get started:   uvx corpo quickstart        Everything you need to know   uvx
  corpo init              Generate identity keypair + config   uvx corpo
  register --email  Create an account and get an API key   uvx corpo form
  File a new Wyoming DAO LLC   uvx corpo <command> --help  Help for a specific
  command

  KEYPAIR SECURITY   Your keypair at ~/.corpo/keypair.json controls real
  funds.   1. BACK UP your keypair immediately: cp ~/.corpo/keypair.json <safe
  location>   2. NEVER share your keypair file or its contents   3. If you
  lose your keypair, you lose access to your entities and funds

```

## 2. Quickstart Guide

```bash
uv run python -m corpo quickstart 2>&1 | head -30
```

```output
CORPO QUICKSTART — Everything an agent needs to know
=====================================================

WHAT IS CORPO?
  Corpo lets AI agents form and govern real legal entities. You create a
  Wyoming DAO LLC — a real company filed with the Wyoming Secretary of State,
  assigned an EIN, capable of holding assets, entering contracts, and
  operating autonomously through on-chain governance.

  The entity is yours. The governance is code. The interface is this CLI.

WHY WYOMING?
  Wyoming's DAO LLC statute (W.S. 17-31) is the only US framework that gives
  smart contracts legal force. The operating agreement can live in code.
  Members can be entities — including AI agents.

SETUP (one-time)
  1. Initialize identity:    uvx corpo init
  2. Register an account:    uvx corpo register --email <email>
  3. Check your identity:    uvx corpo status

FORM AN ENTITY
  1. Get a pricing quote:    uvx corpo quote "YourName LAO LLC"
     Entity names must end in "LAO LLC" or "LAO L.L.C."
  2. Interactive formation:  uvx corpo form
     Or non-interactive:     uvx corpo form --non-interactive > schema.json
                             uvx corpo form post '<json>'
  3. Pay the quote:          uvx corpo pay --quote-id <id>

GOVERN YOUR ENTITY
```

## 3. Identity Initialization

```bash
uv run python -m corpo init 2>&1
```

```output
{
  "ok": true,
  "data": {
    "pubkey": "8PmXhkgkBgdyckDq6P83f4WbwQ4JodPmZAMZUBmnYBgH",
    "keypair_path": "/Users/pv/.corpo/keypair.json",
    "config_path": "/Users/pv/.corpo/config.toml",
    "keypair_status": "existing keypair preserved (not overwritten)",
    "config_status": "existing config preserved"
  }
}
```

Note the keypair_status field — init now tells you whether it generated a new keypair or preserved an existing one.

## 4. Version

```bash
uv run python -m corpo -- --version 2>&1
```

```output
corpo, version 0.2.0
```

## 5. Form System — Non-interactive JSON Schema

```bash
uv run python -m corpo form --non-interactive 2>&1 | head -25
```

```output
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Form a Wyoming DAO LLC",
  "description": "Create a real Wyoming LAO (Limited Autonomous Organization) LLC with on-chain governance.",
  "type": "object",
  "properties": {
    "entity_name": {
      "description": "Wyoming requires a legal suffix. Corpo uses LAO (Limited Autonomous Organization) to signal compliance.",
      "type": "string",
      "x-validation": "Must end in 'LAO LLC' or 'LAO L.L.C.'"
    },
    "entity_type": {
      "description": "Currently only DAO LLC formation is supported.",
      "type": "string",
      "enum": [
        "dao_llc"
      ],
      "default": "dao_llc"
    },
    "registered_agent": {
      "description": "Wyoming requires a registered agent in-state. Corpo partners with Wyoming Agents.",
      "type": "string",
      "default": "Wyoming Agents (wyomingagents.com)"
    },
    "management_type": {
```

## 6. Form Post — Validate JSON submission

```bash
uv run python -m corpo form post '{"entity_name": "Greenriders LAO LLC", "entity_type": "dao_llc", "initial_token_supply": 1000000, "voting_threshold": 50}' 2>&1
```

```output
{
  "ok": true,
  "data": {
    "valid": true,
    "errors": [],
    "error": "No API key configured. Run `corpo register` first."
  }
}
```

Validation passes but no API key is configured — expected since we haven't registered.

## 7. Form Post — Validation error

```bash
uv run python -m corpo form post '{"entity_name": "BadName", "entity_type": "dao_llc"}' 2>&1; true
```

```output
{
  "ok": false,
  "errors": [
    {
      "field": "entity_name",
      "section": "basics",
      "error": "Entity name must end in 'LAO LLC' or 'LAO L.L.C.' \u2014 e.g. 'Alpine LAO LLC'"
    }
  ]
}
```

Names without the LAO LLC suffix are rejected with a clear error.

## 8. FAQ Hints

```bash
uv run python -m corpo form faq --field name 2>&1
```

```output
{
  "ok": true,
  "data": {
    "hints": [
      {
        "question": "Why 'LAO' instead of 'DAO'?",
        "answer": "Corpo uses LAO (Limited Autonomous Organization) exclusively. It signals legal compliance + limited liability protection and distinguishes from informal/unregistered DAOs. Names ending in 'DAO', 'DAO LLC', 'LLC', or 'L.L.C.' are rejected.",
        "statutory_reference": "W.S. 17-31-104(d)",
        "category": "entity_naming"
      }
    ]
  }
}
```

## 9. Form Schema Dump

```bash
uv run python -m corpo form schema 2>&1 | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps({\"form_id\": d[\"data\"][\"form_id\"], \"version\": d[\"data\"][\"version\"], \"sections\": [s[\"title\"] for s in d[\"data\"][\"sections\"]]}, indent=2))"
```

```output
{
  "form_id": "entity-formation",
  "version": "1.0.0",
  "sections": [
    "Entity Basics",
    "Registered Agent & Management",
    "Governance Configuration",
    "Support Corpo"
  ]
}
```

Four sections now — the new 'Support Corpo' section includes the governance token donation option.

## 10. Config Commands

```bash
uv run python -m corpo config show 2>&1
```

```output
{
  "ok": true,
  "data": {
    "api_url": "https://api.corpo.dev/api/v1",
    "api_key": "",
    "account_id": "",
    "default_output": "table"
  }
}
```

## 11. Auth Status (no key)

```bash
uv run python -m corpo auth status 2>&1; true
```

```output
{
  "ok": false,
  "error": "No API key configured",
  "hint": "Run `corpo register` first or set CORPO_API_KEY"
}
```

Clear error messages with actionable hints — designed for agent consumption.

## 12. Subcommand Help Examples

```bash
uv run python -m corpo form -- --help 2>&1
```

```output
Usage: python -m corpo form [OPTIONS] COMMAND [ARGS]...

  Interactive formation forms — step-by-step Q&A or JSON schema mode.

  Modes:
    corpo form                       Interactive Q&A (default)
    corpo form --non-interactive     Dump JSON schema for programmatic use
    corpo form post '<json>'         Validate and submit JSON data
    corpo form faq                   Show legal FAQ hints

Options:
  --non-interactive  Dump JSON schema instead of interactive Q&A
  --form-type TEXT   Form type [default: entity-formation]
  --no-hints         Hide FAQ hints during interactive flow
  --help             Show this message and exit.

Commands:
  faq     Show legal FAQ hints relevant to formation fields.
  post    Validate and submit form data as JSON.
  schema  Dump the full form definition (sections, fields, validation...
```

```bash
uv run python -m corpo actions -- --help 2>&1
```

```output
Usage: python -m corpo actions [OPTIONS] COMMAND [ARGS]...

  Corporate actions — governance moves for your entity.

  Commands: corpo actions list, corpo actions start, corpo actions status

Options:
  --help  Show this message and exit.

Commands:
  catalog  Show the full catalog of corporate action types.
  execute  Advance a corporate action to the next lifecycle stage.
  list     List available and active actions for an entity.
  start    Start a corporate action for an entity.
  status   Check the status of a corporate action.
```

```bash
uv run python -m corpo recipes -- --help 2>&1
```

```output
Usage: python -m corpo recipes [OPTIONS] COMMAND [ARGS]...

  Recipes — pre-built sequences of corporate actions.

  Commands: corpo recipes list, corpo recipes show, corpo recipes run

Options:
  --help  Show this message and exit.

Commands:
  list  List all available recipes.
  run   Execute a recipe against an entity.
  show  Show details of a specific recipe.
```

## 13. Tests

```bash
uv run python -m pytest tests/ -q -k 'not test_status_no_keypair' 2>&1
```

```output
........................................................................ [ 84%]
.............                                                            [100%]
85 passed, 1 deselected in 0.16s
```

## 14. Showboat Features — Verify

Re-run all code blocks and confirm outputs still match:

```bash
uvx showboat verify demos/demo.md 2>&1; echo "Exit code: $?"
```

```output
block 42:
  expected: ........................................................................ [ 84%]
.............                                                            [100%]
85 passed, 1 deselected in 0.16s
  actual:   ........................................................................ [ 84%]
.............                                                            [100%]
85 passed, 1 deselected in 0.14s
Exit code: 1
```

Verify reports a timing difference in the test output (0.16s vs 0.14s) — content is identical, only the timing varies between runs. This is expected for test output.

## 15. Showboat Features — Extract

```bash
uvx showboat extract demos/demo.md 2>&1 | head -10
```

```output
showboat init demos/demo.md 'corpo CLI — Full Feature Exercise'
showboat note demos/demo.md 'This demo exercises every feature of the corpo CLI. The API servers are offline, so commands that require a network connection will fail with connection errors — that'\''s expected. We focus on local features: help text, quickstart, init, form schema, configuration, and FAQ.

## 1. Help & Discovery'
showboat exec demos/demo.md bash 'uv run python -m corpo -- --help 2>&1 | head -20'
showboat note demos/demo.md '## 2. Quickstart Guide'
showboat exec demos/demo.md bash 'uv run python -m corpo quickstart 2>&1 | head -30'
showboat note demos/demo.md '## 3. Identity Initialization'
showboat exec demos/demo.md bash 'uv run python -m corpo init 2>&1'
showboat note demos/demo.md 'Note the keypair_status field — init now tells you whether it generated a new keypair or preserved an existing one.
```

Extract emits the exact showboat commands needed to recreate this demo from scratch — useful for reproducibility and CI.
