@baseline-markets/cli 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baseline-markets/cli",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "repository": {
     "type": "git",

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

@@ -1,33 +1,303 @@
 ---
+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
-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.
+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]
 ---
 
-# Baseline Base MCP
+# Baseline Plugin
 
-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.
+> [!IMPORTANT]
+> Complete the Base MCP onboarding flow before calling any Baseline flow. This
+> skill requires a shell-capable harness and a connected Base Account.
 
-## Quick Start
+## Overview
 
-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.
+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.
 
-## Boundary
+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.
 
-- 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.
+Chains:
 
-## Distribution
+- 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`.
 
-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.
+## 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`.

package/skills/{launch → baseline-cli}/SKILL.md

@@ -1,15 +1,19 @@
 ---
-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`.
+name: baseline-cli
+description: Guides agents through Baseline CLI workflows.
 ---
 
-# Launch
+# Baseline CLI
 
-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.
+Use this skill when a user wants an agent to use the Baseline CLI beyond a
+single command reference. The generated command skills (`baseline-launch` and
+`baseline-info`) document flags; this skill documents the launch workflow,
+artifact contract, validation rules, and execution boundaries.
 
-## Quick Start
+## Launch Workflow
+
+Default to building and reviewing an unsigned call artifact. Execute only when
+the user explicitly asks for local signer submission.
 
 Show the command surface first when inputs are unclear:
 
@@ -63,8 +67,8 @@ 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.
+`zrp` is the default zero-reserve pool 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:
@@ -91,8 +95,8 @@ 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`.
+Do not use `--execute` for external executors such as Base MCP; those consume
+`artifact.calls`.
 Never print, commit, or persist private keys.
 
 ## Defaults And Notes
@@ -101,6 +105,8 @@ Never print, commit, or persist private keys.
 - `--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%`.
+- Swap fee defaults to `1%`; change it with `--swap-fee-pct <percent>`.
+- Creator fee share defaults to `50%`, with the remaining fee share going to
+  stakers; change the split with `--creator-fee-pct <percent>`.
 - Creator defaults to `account`; fee recipient defaults to creator.
 - Salt is optional and must be bytes32 when provided.

package/skills/aeon-baseline/SKILL.md

@@ -1,154 +0,0 @@
----
-name: aeon-baseline
-description: Execute a Baseline launch call artifact through an Aeon operator workflow.
-var: ""
-tags: [crypto, onchain]
-capabilities: [external_api, writes_external_host, onchain_writes, sends_notifications]
----
-
-> **${var}** - Path to a saved `baseline launch` JSON artifact, or empty
-> when `run.vars.launchArtifact` already contains the artifact object. If
-> neither is available, notify `LAUNCH_BASELINE_NO_ARTIFACT` and stop.
-
-Today is ${today}. Execute a Baseline launch call artifact through the
-configured Aeon operator surface without inventing calldata, signers, or wallet
-policy.
-
-## Required Config
-
-- `AEON_RUN_URL` is required only when dispatching this skill through the
-  repository CLI executor.
-- `AEON_AUTH_TOKEN` is optional and is sent as `Authorization: Bearer ...` by
-  the CLI executor when configured.
-- The launch artifact must already be produced by `baseline launch`.
-- Aeon execution is Base mainnet only in v1.
-- Register this skill in an Aeon instance by copying this folder under
-  `skills/`, running `./generate-skills-json`, and adding an `aeon.yml` entry
-  with `enabled: false` and `schedule: "manual"` until an operator explicitly
-  enables it.
-
-## CLI Artifact Contract
-
-`baseline launch` builds and validates the canonical call artifact. The
-`--output` file is the source of truth:
-
-```json
-{
-  "chainId": 8453,
-  "chain": "base",
-  "account": "0xAeonOperatorWallet",
-  "bToken": "0x...",
-  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
-}
-```
-
-Required Aeon launch inputs:
-
-- `--mode zrp` or `--mode standard`
-- `--chain-id 8453`
-- `--account "$AEON_OPERATOR_WALLET"`
-- `--name "$TOKEN_NAME"`
-- `--symbol "$TOKEN_SYMBOL"`
-- `--reserve 0x4200000000000000000000000000000000000006`
-- `--total-supply "$TOTAL_SUPPLY"`
-- `--initial-pool-btokens "$POOL_BTOKENS"` for `standard`
-- `--initial-pool-reserves "$RESERVE_SEED"` for `standard`
-- `--output .context/launches/aeon-launch.json`
-
-Key optional controls:
-
-- Fees: `--swap-fee-pct` and `--creator-fee-pct`.
-- Parties and salt: `--creator`, `--fee-recipient`, and `--salt`.
-
-Build the handoff artifact before running this skill:
-
-```sh
-baseline launch \
-  --mode zrp \
-  --chain-id 8453 \
-  --account "$AEON_OPERATOR_WALLET" \
-  --name "$TOKEN_NAME" \
-  --symbol "$TOKEN_SYMBOL" \
-  --reserve 0x4200000000000000000000000000000000000006 \
-  --total-supply "$TOTAL_SUPPLY" \
-  --output .context/launches/aeon-launch.json
-```
-
-Before Aeon execution, verify `chainId`, `account`, call count, call order,
-allowed targets, and selected mode economics. `zrp` artifacts use
-three calls and all BTokens in the pool. `standard` artifacts use four calls,
-a nonzero reserve seed, and `createPool`.
-
-## Steps
-
-1. **Load the artifact.** If `run.vars.launchArtifact` exists, use it.
-   Otherwise read the JSON file path from `${var}`. If both are absent, run:
-
-```sh
-./notify "LAUNCH_BASELINE_NO_ARTIFACT: provide var=<path-to-launch-artifact.json> or run.vars.launchArtifact"
-```
-
-Then stop.
-
-2. **Validate the artifact.** Confirm:
-
-- `chainId` is `8453`.
-- `account` is present and is the expected Aeon operator wallet.
-- `calls` is an array with exactly three or four items.
-- Every call has `to`, `data`, and `value`.
-
-3. **Validate transaction shape.** Confirm the call order matches the selected
-   mode:
-
-- `zrp`: Relay `createBToken`, BToken `approve`, Relay
-  `createPoolFromInvariant`.
-- `standard`: Relay `createBToken`, BToken `approve`, reserve `approve`, Relay
-  `createPool`.
-
-Reject any artifact whose targets are outside the Baseline Relay, precomputed
-BToken, and reserve token.
-
-4. **Respect the executor boundary.** Do not sign directly, do not ask for a
-   private key, and do not rebuild calldata by hand. Use the artifact calls
-   exactly as produced by the CLI or abort with a notification explaining the
-   mismatch.
-
-5. **Submit through the configured Aeon operator workflow.** If this skill is
-   running inside Aeon with a wallet-capable operator surface, submit the
-   ordered Base mainnet calls according to that operator's configured wallet
-   policy. If no wallet execution surface is configured, emit a handoff
-   notification and stop without broadcasting.
-
-6. **Verify on-chain state.** After a successful run, perform read-only checks:
-
-- BToken code is non-empty.
-- Maker initialization is true.
-- Reserve equals Base WETH.
-- Creator and fee recipient match the artifact expectations.
-- For `zrp`, total reserves and deployer BToken balance are `0`.
-
-7. **Log.** Append to `memory/logs/${today}.md`:
-
-```markdown
-## aeon-baseline
-- Artifact: ARTIFACT_PATH_OR_INLINE
-- Chain ID: 8453
-- Account: ACCOUNT
-- Status: SUBMITTED | HANDOFF_READY | VERIFIED | REJECTED
-- Transaction hashes: HASHES_OR_NONE
-```
-
-8. **Notify.** Send a notification under 4000 characters:
-
-```text
-Baseline launch: STATUS
-Account: ACCOUNT
-Txs: HASHES_OR_HANDOFF
-Next: verification summary or rejection reason
-```
-
-## Sandbox Note
-
-Authenticated wallet or run APIs may not be reachable from the Claude sandbox.
-If secrets are unavailable, do not fail noisily or fabricate execution. Notify
-`LAUNCH_BASELINE_HANDOFF_READY`, write the handoff details to memory, and stop.

package/skills/bankr-baseline/SKILL.md

@@ -1,260 +0,0 @@
----
-name: bankr-baseline
-description: Build Baseline launch call artifacts and submit them with Bankr Wallet API
-tags: [crypto, baseline, token, erc20]
-version: 1
----
-
-# Bankr Baseline
-
-Use this skill when a user wants an agent to plan and deploy a Baseline token
-with this repository's `baseline` CLI and Bankr's Wallet API.
-
-## Skill Contract
-
-| Field | Requirement |
-|---|---|
-| Purpose | Build, review, and submit explicit Baseline launch calls. |
-| Supported chain | Confirmed Bankr execution uses Base mainnet, chain ID `8453`. |
-| Pending validation | Base Sepolia `84532` needs authenticated Wallet API validation before Bankr execution. |
-| Planner | The local `baseline` CLI is the launch calldata builder. |
-| Protocol surface | The CLI uses Baseline SDK/protocol helpers for economics, addresses, and calldata. |
-| Wallet executor | Bankr provides wallet identity, signing, and transaction submission only. |
-| Allowed Bankr endpoints | `GET /wallet/me` and `POST /wallet/submit`. |
-| Canonical artifact | `baseline launch` call artifact with `{ chainId, chain, account, bToken, calls }`. |
-| Hard stops | No private keys, Bankr native launches, Agent API prompts, or hand-built calldata. |
-
-Base MCP remains the confirmed Sepolia test executor in this repository. Bankr
-Wallet API docs document explicit transaction submission by `chainId`, but do
-not currently document Base Sepolia `84532` as supported. Do not use Bankr for
-Base Sepolia execution until an authenticated validation run proves support.
-
-## Protocol Constants
-
-| Chain | Chain ID | Reserve | Use |
-|---|---:|---|---|
-| Base Sepolia | `84532` | `0xB85885897D297000A74eA2e4711C3Ca729461ABC` | Pending Bankr validation. |
-| Base mainnet | `8453` | `0x4200000000000000000000000000000000000006` | Approved production launches. |
-
-Baseline Relay proxy on both profiles:
-`0xc81Fd894C0acE037d133aF4886550aC8133568E8`.
-
-## Required Setup
-
-- `BANKR_API_KEY` must be set only in the local execution environment or secret
-  manager.
-- Optional: `BANKR_API_BASE`, defaulting to `https://api.bankr.bot`.
-- The Bankr key must have Wallet API write access enabled and must not be
-  read-only.
-- Raw `/wallet/submit` cannot be used when the key has `allowedRecipients`
-  restrictions, because Bankr blocks raw submissions for those keys.
-- The Bankr EVM wallet returned by `/wallet/me` is the Baseline launch
-  `account` unless the user explicitly chooses another supported policy.
-
-## CLI Artifact Contract
-
-The CLI is the only Baseline launch calldata builder in this workflow. It
-collects launch inputs, applies defaults, calls SDK-backed protocol helpers,
-builds ordered raw calls, and writes a JSON artifact. It does not custody keys
-or sign transactions.
-
-`baseline launch` writes the canonical artifact:
-
-```json
-{
-  "chainId": 8453,
-  "chain": "base",
-  "account": "0xBankrWallet",
-  "bToken": "0x...",
-  "calls": [{ "to": "0x...", "data": "0x...", "value": "0x0" }]
-}
-```
-
-Required Bankr launch flags:
-
-| Flag | Required value | Description |
-|---|---|---|
-| `--mode` | `zrp` by default, `standard` when a reserve seed is required | Selects the Baseline launch path. |
-| `--chain-id` | `8453` | Keeps Bankr on the confirmed Base mainnet execution chain. |
-| `--account` | `"$BANKR_WALLET"` | Uses the EVM wallet returned by Bankr `/wallet/me`. |
-| `--name` | `"$TOKEN_NAME"` | Sets the BToken name passed to the Baseline Relay. |
-| `--symbol` | `"$TOKEN_SYMBOL"` | Sets the BToken symbol passed to the Baseline Relay. |
-| `--reserve` | Base mainnet WETH | Uses the confirmed reserve token. |
-| `--total-supply` | Launch-specific supply | Sets human-unit total supply. |
-| `--initial-pool-btokens` | Required for `standard`; omit for `zrp` | Sets the pool BToken amount while leaving circulating supply. |
-| `--initial-pool-reserves` | Required for `standard` | Sets the reserve seed. |
-| `--output` | `.context/launches/bankr-launch.json` | Saves the artifact under `.context/`. |
-
-Important optional launch flags:
-
-| Category | Flags | Description |
-|---|---|---|
-| Fees | `--swap-fee-pct`, `--creator-fee-pct` | Defaults are `1%` and `50%`; swap fee protocol bounds are `0.15%` to `50%`. |
-| Parties | `--creator`, `--fee-recipient` | Creator defaults to `account`; fee recipient defaults to creator. |
-| Salt | `--salt` | Sets deterministic BToken salt; empty input uses zero `bytes32`. |
-
-## Default Launch Profile
-
-### ZRP
-
-| Setting | Default | Notes |
-|---|---|---|
-| Mode | `zrp` | Default launch path. |
-| Chain ID | `8453` for Bankr | Bankr remains Base mainnet only. |
-| Supply | `100B` | Human-unit total supply when not overridden. |
-| Pool BTokens | Derived from `totalSupply` | Deployer BToken balance is `0`. |
-| Pool reserves | `0` | No reserve approval is expected. |
-| Reserve | Base mainnet WETH | `0x4200000000000000000000000000000000000006`. |
-| Swap fee | `1%` | Must stay within protocol bounds. |
-| Creator fee share | `50%` | Creator share of pool fees. |
-| Creator | Bankr EVM wallet | Override only when explicitly requested. |
-| Fee recipient | Creator | Override only when explicitly requested. |
-| `createHook` | `true` | Matches the current SDK launch params. |
-
-### Standard
-
-| Setting | Default | Notes |
-|---|---|---|
-| Mode | `standard` | Explicit standard launch path. |
-| Chain ID | `8453` for Bankr | Bankr remains Base mainnet only. |
-| Pool BTokens | User supplied | Must leave circulating supply. |
-| Pool reserves | User supplied | Must be nonzero. |
-| Pool creation | `createPool` | Uses the `createPool` Relay flow. |
-| Shared fees and parties | Same as `zrp` | Override only with explicit fee, creator, or recipient flags. |
-| `createHook` | `true` | Matches the current SDK launch params. |
-
-## Baseline Launch Call Sequence
-
-The Baseline protocol launch is represented as an ordered call sequence inside
-the CLI-generated artifact. Bankr does not decide this sequence. Bankr only
-identifies the wallet and signs/submits the explicit calls that the CLI
-produces.
-
-For `zrp`, the sequence is:
-
-| Order | Step | Transaction purpose |
-|---|---|---|
-| 1 | `createBToken` | Deploy the planned BToken through the Baseline Relay. |
-| 2 | BToken `approve` | Approve the Baseline Relay to move the full BToken supply for pool creation. |
-| 3 | `createPoolFromInvariant` | Create the pool from the computed invariant and planned params. |
-
-For `standard`, the sequence is:
-
-| Order | Step | Transaction purpose |
-|---|---|---|
-| 1 | `createBToken` | Deploy the planned BToken through the Baseline Relay. |
-| 2 | BToken `approve` | Approve the Baseline Relay to move the planned BToken pool allocation. |
-| 3 | Reserve `approve` | Approve the Baseline Relay to move the planned reserve seed. |
-| 4 | `createPool` | Create the pool with standard params, fees, creator, and fee recipient. |
-
-These calls are dependent. If a live run partially completes, do not replay the
-full sequence blindly. Verify the last completed on-chain step and recover from
-that exact state.
-
-## Execution Plan
-
-1. Resolve the Bankr EVM wallet with `/wallet/me`.
-2. Use that wallet as `--account` for the local CLI artifact builder.
-3. Confirm the user explicitly approved a Bankr Base mainnet run.
-4. Run `baseline launch --chain-id 8453` and save the artifact.
-5. Review the saved artifact: `chainId`, `account`, ordered call count, call
-   targets, and call data.
-6. Submit each artifact call through Bankr Wallet API `/wallet/submit` in
-   order. Wait for each submission result before sending the next dependent
-   call.
-7. Verify on-chain state and store one-off run notes under `.context/`.
-
-## Commands
-
-Read the Bankr wallet identity:
-
-```sh
-BANKR_API_BASE="${BANKR_API_BASE:-https://api.bankr.bot}"
-curl -s "$BANKR_API_BASE/wallet/me" \
-  -H "X-API-Key: $BANKR_API_KEY"
-```
-
-Build a Bankr Base mainnet artifact with the local CLI:
-
-```sh
-baseline launch \
-  --mode zrp \
-  --chain-id 8453 \
-  --account "$BANKR_WALLET" \
-  --name "$TOKEN_NAME" \
-  --symbol "$TOKEN_SYMBOL" \
-  --reserve 0x4200000000000000000000000000000000000006 \
-  --total-supply "$TOTAL_SUPPLY" \
-  --output .context/launches/bankr-launch.json
-```
-
-For a `standard` launch, include `--initial-pool-reserves "$RESERVE_SEED"` and
-set `--initial-pool-btokens` below `--total-supply`.
-
-Submit each call in order through Bankr:
-
-```http
-POST /wallet/submit
-X-API-Key: $BANKR_API_KEY
-Content-Type: application/json
-
-{
-  "chainId": 8453,
-  "to": "<call.to>",
-  "data": "<call.data>",
-  "value": "<call.value>"
-}
-```
-
-## Review Checklist
-
-Before any live submission, confirm:
-
-- The user explicitly authorized Bankr live execution on Base mainnet.
-- `BANKR_API_KEY` is set for a live run and is not exposed in tracked files.
-- `/wallet/me` returns an EVM wallet address.
-- `artifact.chainId` is `8453`.
-- `artifact.account` equals the Bankr EVM wallet unless the user explicitly
-  chose another supported policy.
-- The transaction order and count match the selected CLI mode.
-- Transaction targets are limited to the Baseline Relay, precomputed BToken,
-  and reserve token.
-- `zrp` artifacts use all BTokens in the pool and no reserve approval.
-- `standard` artifacts include the intended reserve seed and circulating supply.
-
-## Verification
-
-After a successful live run, perform read-only verification:
-
-- BToken code is non-empty.
-- `bLens.getMaker(bToken).initialized` is true.
-- `bLens.reserve(bToken)` equals the planned chain reserve.
-- `bLens.creator(bToken)` equals the planned creator.
-- `bLens.poolFeeRecipient(bToken)` equals the planned fee recipient.
-- For `zrp`, total reserves and deployer BToken balance are both `0`.
-- For `standard`, deployer BToken balance matches the planned circulating
-  allocation, allowing for integer division.
-
-## Rejection Rules
-
-Stop before live submission if:
-
-- The user has not explicitly authorized Bankr live execution.
-- Base mainnet execution is implied but not explicitly approved.
-- `BANKR_API_KEY` is missing for a live run.
-- `/wallet/me` does not return an EVM wallet address.
-- The artifact is not for chain ID `8453`.
-- The prepared transaction order or count differs from the selected CLI mode.
-- Any requested flow involves raw private keys, seed phrases, local production
-  signing, Bankr native launch endpoints, or Agent API prompts.
-
-## Troubleshooting
-
-- `403`: confirm Wallet API write access, read-only mode, IP allowlist, and
-  absence of `allowedRecipients` restrictions.
-- Base Sepolia requested: use Base MCP for the confirmed Sepolia path, or run a
-  separate authenticated Bankr validation task before enabling Bankr Sepolia.
-- Missing transaction hash: treat the phase as ambiguous and perform read-only
-  on-chain verification before retrying.
-- Partial failure: do not replay the full sequence blindly. Recover from the
-  exact last verified phase.

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

@@ -1,240 +0,0 @@
----
-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`.