@baseline-markets/cli 0.2.2 → 0.3.0

package/skills/base-mcp-baseline/SKILL.md

@@ -1,303 +1,33 @@
 ---
-title: "Baseline Plugin"
-description: "Launch Baseline tokens with the Baseline CLI, then submit unsigned calls through Base MCP send_calls."
-tags: [token-launches, liquidity, ai-agents]
 name: base-mcp-baseline
-version: 0.2.0
-integration: cli-only
-chains: [base, base-sepolia, ethereum]
-requires:
-  shell: required
-  allowlist: []
-  externalMcp: null
-  cliPackage: "npx @baseline-markets/cli@latest"
-auth: none
-risk: [low-liquidity, irreversible, local-exec]
+description: Vendors the Baseline plugin for Base MCP so agents can launch Baseline tokens with the Baseline CLI and Base Account approval. Use when a user wants to use Base MCP, Base Account, send_calls, or the Baseline CLI to prepare and submit a Baseline token launch.
 ---
 
-# Baseline Plugin
+# Baseline Base MCP
 
-> [!IMPORTANT]
-> Complete the Base MCP onboarding flow before calling any Baseline flow. This
-> skill requires a shell-capable harness and a connected Base Account.
+This skill packages the Baseline Base MCP plugin with `@baseline-markets/cli`.
+The plugin file is the source of truth; do not duplicate or improvise the launch
+workflow here.
 
-## Overview
+## Quick Start
 
-Baseline is an AMM for tokens with token-owned liquidity that grows itself. A 
-Baseline token operates its own liquidity pool, so a creator or agent can launch
-without managing external LP positions, capture swap fees that would otherwise go
-to outside liquidity providers, and split those fees between a creator recipient
-and token stakers. This skill launches a Baseline token on Ethereum mainnet, Base
-mainnet, or Base Sepolia by running the Baseline CLI to prepare unsigned launch
-calls, then submitting those calls through Base MCP's `send_calls`, where the
-user approves in Base Account.
+1. If the installed Base MCP skill already includes a native `baseline` plugin,
+   use that native plugin.
+2. Otherwise, read and follow [plugins/baseline.md](plugins/baseline.md).
+3. Use the local `baseline` binary when available; otherwise use the `npx`
+   command documented in the plugin.
 
-This is a CLI-only Base MCP plugin flow: it only works in harnesses with
-shell/terminal access. It does not work on chat-only surfaces that cannot run
-commands. No additional MCP server is required beyond Base MCP.
+## Boundary
 
-Chains:
+- The installed Base MCP skill/server is still required.
+- The Baseline CLI prepares unsigned launch call artifacts.
+- Base MCP provides wallet identity, Base Account approval, submission, and
+  request-status polling.
+- Do not use `baseline launch --execute` in the Base MCP flow.
+- Do not ask for, load, print, or use a private key.
 
-- Ethereum mainnet: `chainId` `1`, Base MCP chain string `ethereum`.
-- Base mainnet: `chainId` `8453`, Base MCP chain string `base`.
-- Base Sepolia: `chainId` `84532`, Base MCP chain string `base-sepolia`.
+## Distribution
 
-## Installation
-
-No MCP registration or permanent install is required; the CLI runs per call via
-`npx`.
-
-Use an installed CLI when available:
-
-```sh
-baseline launch --help
-```
-
-Otherwise invoke the published package:
-
-```sh
-npx @baseline-markets/cli@latest launch --help
-```
-
-## Surface Routing
-
-Every launch calldata artifact is built by the Baseline CLI and therefore
-requires a harness with shell/terminal access.
-
-| Surface | Path |
-| --- | --- |
-| Shell-capable harness | Run `baseline launch` or `npx @baseline-markets/cli@latest launch`, validate the artifact, submit via `send_calls`. |
-| Chat-only surface | Not supported. Tell the user this Baseline plugin requires CLI access and stop. Do not route through `web_request`, use a user-paste fallback, ask for private keys, or hand-build calldata. |
-
-## Commands
-
-`baseline launch` writes an unsigned call artifact. The artifact is a superset
-of the `send_calls` payload: `chain` and `calls` are submitted directly, while
-`chainId`, `account`, and `bToken` are validation and reporting metadata.
-
-```json
-{
-  "chainId": 84532,
-  "chain": "base-sepolia",
-  "account": "0xBaseAccount",
-  "bToken": "0xBToken",
-  "calls": [
-    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
-  ]
-}
-```
-
-### Zero-Reserve Pool Launch
-
-Zero-reserve pool launch (`zrp`) is the default mode. It deposits the full
-BToken supply into the pool without initial reserve liquidity.
-
-Base Sepolia example:
-
-```sh
-baseline launch \
-  --mode zrp \
-  --chain-id 84532 \
-  --account "$BASE_MCP_WALLET" \
-  --name "$TOKEN_NAME" \
-  --symbol "$TOKEN_SYMBOL" \
-  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
-  --total-supply "$TOTAL_SUPPLY" \
-  --output .context/launches/baseline-launch.json
-```
-
-### Standard Launch
-
-Standard launches include initial reserve liquidity. Require both the initial
-pool BToken amount and the reserve seed amount.
-
-Base Sepolia example:
-
-```sh
-baseline launch \
-  --mode standard \
-  --chain-id 84532 \
-  --account "$BASE_MCP_WALLET" \
-  --name "$TOKEN_NAME" \
-  --symbol "$TOKEN_SYMBOL" \
-  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
-  --total-supply "$TOTAL_SUPPLY" \
-  --initial-pool-btokens "$POOL_BTOKENS" \
-  --initial-pool-reserves "$RESERVE_SEED" \
-  --output .context/launches/baseline-launch.json
-```
-
-### Chain And Reserve Selection
-
-Use the chain ID and approved reserve token for the selected network:
-
-| Network | `--chain-id` | `artifact.chain` | WETH reserve |
-| --- | --- | --- | --- |
-| Ethereum mainnet | `1` | `ethereum` | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
-| Base mainnet | `8453` | `base` | `0x4200000000000000000000000000000000000006` |
-| Base Sepolia | `84532` | `base-sepolia` | `0xB85885897D297000A74eA2e4711C3Ca729461ABC` |
-
-Treat Ethereum mainnet and Base mainnet as production. Confirm the user
-explicitly requested production execution before preparing calls on either
-mainnet.
-
-Do not pass `--execute`, `--private-key`, or `BASELINE_PRIVATE_KEY` in this
-plugin flow. Base MCP is the only submission path.
-
-### Optional Launch Parameters
-
-Use these flags when the user asks to customize launch ownership or fee routing:
-
-| Flag | Purpose | Default |
-| --- | --- | --- |
-| `--creator <address>` | Creator address recorded on the launch. | Launch account |
-| `--fee-recipient <address>` | Address receiving the creator share of swap fees. | Creator |
-| `--creator-fee-pct <percent>` | Creator share of swap fees, from `0` to `100`. | `50` |
-| `--swap-fee-pct <percent>` | Swap fee charged by the pool. | `1` |
-| `--salt <bytes32>` | Deterministic deployment salt. | Zero bytes32 |
-| `--reserve-decimals <number>` | Decimal precision for `--initial-pool-reserves`. | `18` |
-
-The remaining fee share goes to token stakers. With the default
-`--creator-fee-pct 50`, swap fees are split 50% to the creator fee recipient
-and 50% to stakers.
-
-## Orchestration
-
-### Launch
-
-1. Complete Base MCP onboarding and confirm Base MCP tools are available.
-2. Fetch the wallet address only when needed with `get_wallets`; use the
-   in-session Base Account address as `BASE_MCP_WALLET`.
-3. Gather token name, symbol, total supply, launch mode, chain, reserve token,
-   creator, fee recipient, swap fee, and creator fee. Default to Base Sepolia
-   `84532` and `zrp` unless the user explicitly chooses otherwise.
-4. For `standard`, require both `POOL_BTOKENS` and a nonzero `RESERVE_SEED`.
-   `POOL_BTOKENS` must be less than `TOTAL_SUPPLY` so some supply remains
-   outside the initial pool.
-5. Run `baseline launch` with `--output`. If the CLI exits nonzero, fix inputs
-   and rerun; do not salvage partial output.
-6. Parse the artifact JSON and validate it before submission:
-   - `account` equals the connected Base Account.
-   - `chainId` is `1`, `8453`, or `84532`.
-   - `chain` is `ethereum`, `base`, or `base-sepolia`.
-   - `chain` matches `chainId`.
-   - `bToken` is a valid address.
-   - `calls` is an ordered array and every call has `to`, `data`, and `value`.
-   - No `execution` field is present.
-   - `zrp` has three calls; `standard` has four calls.
-7. For `chainId` `1` or `8453`, confirm the exact chain, token name, symbol,
-   supply, reserve, fees, creator, and fee recipient immediately before
-   `send_calls`.
-8. Submit the calls through `send_calls` as described in [Submission](#submission).
-9. Show the returned approval URL as an `[Approve Transaction](<approvalUrl>)`
-   link, include the request ID, print the link as a fallback, and open it with
-   the local shell when the harness supports that.
-10. Wait for the user to confirm they approved in Base Account, then poll
-    `get_request_status(requestId)`. If it is still pending, retry with a short
-    delay; never report success until the request is completed.
-11. After completion, run `baseline info "$BTOKEN" --chain-id "$CHAIN_ID"`
-    using the artifact `bToken` and `chainId` when the command is available.
-
-## Submission
-
-Submit with Base MCP `send_calls`. Use `artifact.chain` directly and pass
-`artifact.calls` without editing calldata or changing order:
-
-```json
-{
-  "chain": "base-sepolia",
-  "calls": [
-    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
-  ]
-}
-```
-
-Do not include `artifact.account` in the `send_calls` payload; Base MCP uses
-the connected Base Account session for approval and execution.
-
-Expected call sequences:
-
-- `zrp`: Relay `createBToken`, BToken `approve`, Relay
-  `createPoolFromInvariant`.
-- `standard`: Relay `createBToken`, BToken `approve`, reserve `approve`, Relay
-  `createPool`.
-
-Any `send_calls` approval URL follows the standard Base MCP approval flow: show
-the approval URL as an `[Approve Transaction](<approvalUrl>)` link, include the
-request ID, print the link as a fallback, wait for the user to approve in Base
-Account, then poll `get_request_status`.
-
-## Example Prompts
-
-Launch a Base Sepolia test token:
-
-1. Get the Base Account with `get_wallets`.
-2. Run the `zrp` Base Sepolia `baseline launch` command with the requested name,
-   symbol, and supply.
-3. Validate the artifact and call count.
-4. Submit `artifact.calls` to `send_calls` with `chain: artifact.chain`.
-5. Wait for approval, poll status, then run `baseline info`.
-
-Launch a standard token with seed liquidity:
-
-1. Require `POOL_BTOKENS` and `RESERVE_SEED`.
-2. Run `baseline launch --mode standard`.
-3. Confirm the artifact has four ordered calls.
-4. Submit the batch with `send_calls`.
-5. Wait for approval, poll status, then run `baseline info`.
-
-Launch on Base mainnet:
-
-1. Confirm the user explicitly requested Base mainnet production execution.
-2. Use chain ID `8453` and reserve
-   `0x4200000000000000000000000000000000000006`.
-3. Validate the artifact carefully before `send_calls`.
-4. Submit with `chain: "base"` only after the user confirms the mainnet launch.
-
-Use from a chat-only app:
-
-1. Stop.
-2. Explain that this plugin is CLI-only and requires a shell-capable harness.
-3. Do not use HTTP, pasted URLs, private keys, or hand-built calldata as a
-   workaround.
-
-## Risks And Warnings
-
-- `low-liquidity`: New token pools may have thin liquidity and volatile prices.
-  Do not imply liquidity depth, execution quality, or market safety beyond the
-  explicit launch inputs.
-- `irreversible`: A submitted launch cannot be undone through this plugin.
-  Confirm chain, token name, symbol, supply, reserve, fees, creator, and fee
-  recipient before `send_calls`.
-- `local-exec`: The plugin runs the Baseline CLI on the user's machine. Use the
-  installed `baseline` binary when trusted by the user, or the documented
-  `npx @baseline-markets/cli@latest` package invocation.
-
-## Notes
-
-Constants:
-
-```text
-ethereum.chain: ethereum
-ethereum.chainId: 1
-ethereum.reserve: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
-base.chain: base
-base.chainId: 8453
-base.reserve: 0x4200000000000000000000000000000000000006
-baseSepolia.chain: base-sepolia
-baseSepolia.chainId: 84532
-baseSepolia.reserve: 0xB85885897D297000A74eA2e4711C3Ca729461ABC
-relay: 0xc81Fd894C0acE037d133aF4886550aC8133568E8
-zeroBytes32: 0x0000000000000000000000000000000000000000000000000000000000000000
-```
-
-Default launch assumptions:
-
-- `zrp` is the default launch mode.
-- Swap fee defaults to `1%`; protocol bounds are `0.15%` to `50%`.
-- Creator fee share defaults to `50%`; the remaining share goes to token
-  stakers. Change it with `--creator-fee-pct <percent>`.
-- Creator defaults to the launch account.
-- Fee recipient defaults to creator.
-- Salt defaults to zero `bytes32`.
-- Reserve decimals default to `18`.
+This wrapper exists so users who discover Baseline through the CLI can install
+the same Base MCP plugin instructions before the plugin is available natively in
+their Base MCP skill bundle.

package/skills/base-mcp-baseline/plugins/baseline.md

@@ -0,0 +1,240 @@
+---
+title: "Baseline Plugin"
+description: "Launch Baseline tokens with the Baseline CLI, then submit unsigned calls through Base MCP send_calls."
+tags: [token-launches, liquidity]
+name: baseline
+version: 0.1.0
+integration: cli-only
+chains: [base, base-sepolia]
+requires:
+  shell: required
+  allowlist: []
+  externalMcp: null
+  cliPackage: "npx @baseline-markets/cli@latest"
+auth: none
+risk: [irreversible, local-exec, low-liquidity]
+---
+
+# Baseline Plugin
+
+> [!IMPORTANT]
+> Run Base MCP onboarding first (defined by the installed Base MCP SKILL.md). This plugin requires a shell-capable harness and a connected Base Account.
+
+## Overview
+
+Baseline is an onchain AMM for leveraged tokens. This plugin launches a
+Baseline token on Base or Base Sepolia by running the Baseline CLI to prepare
+unsigned launch calls, then submitting those calls through Base MCP
+`send_calls` for Base Account approval and execution.
+
+## Installation
+
+No additional MCP server is required. The plugin shells out to the Baseline CLI
+for each prepare step.
+
+Use an installed CLI when available:
+
+```sh
+baseline launch --help
+```
+
+Otherwise invoke the package with `npx`:
+
+```sh
+npx @baseline-markets/cli@latest launch --help
+```
+
+## Surface Routing
+
+| Capability | Shell-capable surfaces | Shell-less / chat-only surfaces |
+|---|---|---|
+| Build launch calldata | Run `baseline launch` or `npx @baseline-markets/cli@latest launch`. | Stop. This plugin is CLI-only and must not use `web_request`, user-paste, or hand-built calldata as a workaround. |
+| Submit prepared calls | Use Base MCP `send_calls`. | Stop unless the surface exposes both Base MCP tools and a way to run the CLI. |
+| Check request status | Use Base MCP `get_request_status` after the user approves in Base Account. | Stop unless the pending request came from a supported CLI prepare flow. |
+
+## Commands
+
+`baseline launch` writes an unsigned call artifact:
+
+```json
+{
+  "chainId": 84532,
+  "chain": "base-sepolia",
+  "account": "0xBaseAccount",
+  "bToken": "0xBToken",
+  "calls": [
+    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
+  ]
+}
+```
+
+Default Base Sepolia zero-reserve launch:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id 84532 \
+  --account "$BASE_ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/baseline-launch.json
+```
+
+Standard launch with reserve liquidity:
+
+```sh
+baseline launch \
+  --mode standard \
+  --chain-id 84532 \
+  --account "$BASE_ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve 0xB85885897D297000A74eA2e4711C3Ca729461ABC \
+  --total-supply "$TOTAL_SUPPLY" \
+  --initial-pool-btokens "$POOL_BTOKENS" \
+  --initial-pool-reserves "$RESERVE_SEED" \
+  --output .context/launches/baseline-launch.json
+```
+
+Base mainnet uses `--chain-id 8453` and WETH reserve
+`0x4200000000000000000000000000000000000006`. Treat mainnet as production and
+confirm the user explicitly requested it before preparing calls.
+
+Do not pass `--execute` or `--private-key` in this plugin flow. Base MCP is the
+only submission path.
+
+## Orchestration
+
+### Launch
+
+1. Complete Base MCP onboarding and confirm Base MCP tools are available.
+2. Call `get_wallets`, confirm the selected chain is in `supportedChains`, and
+   use the in-session Base Account address as `BASE_ACCOUNT`. If the Base
+   Account is not in session, stop and ask the user to reconnect Base MCP.
+3. Gather token name, symbol, total supply, launch mode, and chain. Default to
+   Base Sepolia `84532` and `zrp` unless the user explicitly chooses otherwise.
+4. For `standard`, require both `POOL_BTOKENS` and a nonzero `RESERVE_SEED`.
+   `POOL_BTOKENS` must be less than `TOTAL_SUPPLY` so some supply remains
+   circulating.
+5. Run `baseline launch` with `--output`. If the CLI exits nonzero, fix inputs
+   and rerun; do not salvage partial output.
+6. Parse the artifact JSON and validate it before submission:
+   - `account` equals the connected Base Account.
+   - `chainId` is `84532` or `8453`.
+   - `chain` is `base-sepolia` or `base`.
+   - `bToken` is a valid address.
+   - `calls` is an ordered array and every call has `to`, `data`, and `value`.
+   - No `execution` field is present.
+   - `zrp` has three calls; `standard` has four calls.
+7. Submit the calls through `send_calls` as described in `## Submission`.
+8. Show the returned `approvalUrl` as an "Approve Transaction" link and open it
+   with the local shell when the harness supports that.
+9. Wait for the user to confirm they approved in Base Account, then call
+    `get_request_status(requestId)`. If it is still `pending`, retry with a
+    short delay; never report success until the request is `completed`.
+10. After completion, run
+    `baseline info "$BTOKEN" --chain-id "$CHAIN_ID"` using the artifact
+    `bToken` and `chainId`.
+
+## Submission
+
+Submit with Base MCP `send_calls`.
+
+Map the artifact exactly:
+
+```json
+{
+  "chain": "base-sepolia",
+  "calls": [
+    { "to": "0xTarget", "data": "0xCalldata", "value": "0x0" }
+  ]
+}
+```
+
+Use `artifact.chain` directly. Preserve call order and do not edit calldata. Do
+not include `artifact.account` in the `send_calls` payload; Base MCP uses the
+connected Base Account session for approval and execution.
+
+Expected call sequences:
+
+- `zrp`: Relay `createBToken`, BToken `approve`, Relay
+  `createPoolFromInvariant`.
+- `standard`: Relay `createBToken`, BToken `approve`, reserve `approve`, Relay
+  `createPool`.
+
+Any `send_calls` approval URL follows the Base MCP approval flow: show an
+"Approve Transaction" link, open it from shell-capable harnesses, wait for the
+user to approve in Base Account, then poll `get_request_status`.
+
+## Example Prompts
+
+Launch a Base Sepolia test token:
+
+1. Get the Base Account with `get_wallets`.
+2. Run the `zrp` Base Sepolia `baseline launch` command with the requested name,
+   symbol, and supply.
+3. Validate the artifact and call count.
+4. Submit `artifact.calls` to `send_calls` with `chain: artifact.chain`.
+5. Wait for approval, poll status, then run `baseline info`.
+
+Launch a standard token with seed liquidity:
+
+1. Require `POOL_BTOKENS` and `RESERVE_SEED`.
+2. Run `baseline launch --mode standard`.
+3. Confirm the artifact has four ordered calls.
+4. Submit the batch with `send_calls`.
+5. Wait for approval, poll status, then run `baseline info`.
+
+Launch on Base mainnet:
+
+1. Confirm the user explicitly requested Base mainnet production execution.
+2. Use chain ID `8453` and reserve
+   `0x4200000000000000000000000000000000000006`.
+3. Validate the artifact carefully before `send_calls`.
+4. Submit with `chain: "base"` only after the user confirms the mainnet launch.
+
+User asks to run from a phone or chat-only app:
+
+1. Stop.
+2. Explain that this plugin is CLI-only and requires a shell-capable harness.
+3. Do not use HTTP, pasted URLs, private keys, or hand-built calldata as a
+   workaround.
+
+## Risks & Warnings
+
+- `irreversible`: A submitted launch cannot be undone through this plugin.
+  Confirm chain, token name, symbol, supply, reserve, fees, creator, and fee
+  recipient before `send_calls`.
+- `local-exec`: The plugin runs the Baseline CLI on the user's machine. Use the
+  installed `baseline` binary when trusted by the user, or the documented `npx`
+  package invocation.
+- `low-liquidity`: New token pools may have thin liquidity and volatile prices.
+  Do not imply liquidity, execution quality, or market safety beyond the
+  explicit launch inputs.
+
+## Notes
+
+Constants:
+
+```text
+base.chain: base
+base.chainId: 8453
+base.reserve: 0x4200000000000000000000000000000000000006
+baseSepolia.chain: base-sepolia
+baseSepolia.chainId: 84532
+baseSepolia.reserve: 0xB85885897D297000A74eA2e4711C3Ca729461ABC
+relay: 0xc81Fd894C0acE037d133aF4886550aC8133568E8
+zeroBytes32: 0x0000000000000000000000000000000000000000000000000000000000000000
+```
+
+Default launch assumptions:
+
+- `zrp` is the default launch mode.
+- Swap fee defaults to `1%`; protocol bounds are `0.15%` to `50%`.
+- Creator fee share defaults to `50%`.
+- Creator defaults to the launch account.
+- Fee recipient defaults to creator.
+- Salt defaults to zero `bytes32`.
+- Reserve decimals default to `18`.

package/skills/launch/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: launch
+description: Builds Baseline token launch artifacts with the Baseline CLI and optionally executes them with an explicit signer. Use when a user wants to launch a Baseline token, generate launch calls, create wallet_sendCalls JSON, or use `baseline launch`.
+---
+
+# Launch
+
+Use this skill to guide agents through `baseline launch`. The default workflow
+is to build and review an unsigned call artifact; execute only when the user
+explicitly asks for live submission.
+
+## Quick Start
+
+Show the command surface first when inputs are unclear:
+
+```sh
+baseline launch --help
+```
+
+Build a ZRP launch artifact:
+
+```sh
+baseline launch \
+  --mode zrp \
+  --chain-id "$CHAIN_ID" \
+  --account "$ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve "$RESERVE" \
+  --total-supply "$TOTAL_SUPPLY" \
+  --output .context/launches/baseline-launch.json
+```
+
+## Artifact Contract
+
+`baseline launch` writes wallet_sendCalls-compatible JSON:
+
+```json
+{
+  "chainId": 84532,
+  "chain": "base-sepolia",
+  "account": "0x...",
+  "bToken": "0x...",
+  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
+}
+```
+
+Before handing the artifact to any wallet or execution layer, verify:
+
+- `chainId`, `chain`, and `account` match the intended wallet and chain.
+- `chain` is the executor chain slug, for example `base-sepolia`.
+- `bToken` is the predicted address, not proof of deployment.
+- `calls` is ordered and every call has `to`, `data`, and `value`.
+- `zrp` has three calls; `standard` has four calls.
+- No `execution` field is present unless the user intentionally used
+  `--execute`.
+
+After submission, inspect deployment status and links with:
+
+```sh
+baseline info "$BTOKEN" --chain-id "$CHAIN_ID"
+```
+
+## Launch Modes
+
+`zrp` is the default zero-reserve launch mode. It derives pool BTokens from
+`--total-supply`, has no reserve seed, and has no reserve approval call.
+
+`standard` launches with reserve liquidity and requires both pool BTokens and a
+reserve seed:
+
+```sh
+baseline launch \
+  --mode standard \
+  --chain-id "$CHAIN_ID" \
+  --account "$ACCOUNT" \
+  --name "$TOKEN_NAME" \
+  --symbol "$TOKEN_SYMBOL" \
+  --reserve "$RESERVE" \
+  --total-supply "$TOTAL_SUPPLY" \
+  --initial-pool-btokens "$POOL_BTOKENS" \
+  --initial-pool-reserves "$RESERVE_SEED" \
+  --output .context/launches/baseline-launch.json
+```
+
+## Execution
+
+Only execute when the user explicitly asks for local signer submission.
+
+Reuse the artifact command and add `--execute --private-key "$PRIVATE_KEY"`.
+`BASELINE_PRIVATE_KEY` may be used instead of `--private-key`. `--account` is
+optional with `--execute` because the CLI can derive it from the private key.
+The CLI sends sequential transactions and returns `execution.transactions`.
+Do not use `--execute` for external executors such as Base MCP, Bankr, or Aeon;
+those consume `artifact.calls`.
+Never print, commit, or persist private keys.
+
+## Defaults And Notes
+
+- `--chain-id` must be a chain supported by the installed Baseline CLI/SDK.
+- `--reserve` must be the intended reserve token on that chain.
+- Require explicit user approval before preparing or executing a production
+  launch.
+- Swap fee defaults to `1%`; creator fee share defaults to `50%`.
+- Creator defaults to `account`; fee recipient defaults to creator.
+- Salt is optional and must be bytes32 when provided.