@pnlmarket/mcp-server 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bishwanath Bastola
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,216 @@
+# `@pnlmarket/mcp-server`
+
+The Model Context Protocol server for [PNL](https://pnl.market) — let
+your agent (Claude Code, Cursor, Cline, Codex, the next one) browse
+live conviction markets on Solana, pitch new ideas as markets, and
+stake YES / NO without leaving the terminal.
+
+PNL is a coordination market for ideas. Anyone posts an idea for ~$2
+in SOL; a global market of believers and critics stakes real SOL on
+whether it deserves to launch as a token on pump.fun. YES wins → token
+auto-launches, founder earns royalties. NO wins → critics split the
+pool, paid for filtering noise. The protocol is documented at
+[docs.pnl.market](https://docs.pnl.market) (MIT licensed, open public
+API, manifesto + transparency disclosures published).
+
+This MCP server is the bridge from your agent window into that
+market.
+
+## Status
+
+**v0.3.0 — autosign live.** 13 tools across read, identity, wallet,
+and market actions.
+
+### Read tools (no auth)
+
+| Tool | What it does |
+|---|---|
+| `pnl_help` | Discovery menu — every tool, current wallet state, next step |
+| `pnl_browse_markets` | List live (or historical) conviction markets, filter by status, paginate |
+| `pnl_get_market` | Fetch a single market's full state by id or on-chain address |
+
+### Wallet tools (local, encrypted at rest)
+
+| Tool | What it does |
+|---|---|
+| `pnl_init` | First-run: generate BIP39 mnemonic + Ed25519 keypair, encrypt with passphrase, write to `~/.config/pnl/wallet.enc` (mode 0600) |
+| `pnl_wallet` | Address, balance, lock state, autosign cap, active RPC |
+| `pnl_unlock` | Decrypt secret in memory for N min (default 5, max 60). Passphrase via `PNL_PASSPHRASE` env or OS-native dialog — **never** typed in chat |
+| `pnl_lock` | Wipe cached secret immediately |
+| `pnl_restore` | Rebuild wallet on a new machine from a BIP39 mnemonic |
+| `pnl_export_keypair` | Write secret to a 0600 file for password-manager backup (path returned, never the secret itself) |
+
+### Identity
+
+| Tool | What it does |
+|---|---|
+| `pnl_set_username` | Claim or rename your PNL username — signature-auth, no Privy session needed |
+
+### Market actions
+
+Two flows for each write action:
+
+- **Deep-link** (browser signs) — works on any wallet, no MCP unlock needed
+- **Autosign** (MCP signs locally) — for amounts inside the autosign cap, no browser bounce
+
+| Tool | Mode | What it does |
+|---|---|---|
+| `pnl_pitch_idea` | Deep-link | Draft a market, return `pnl.market/create?draft=<id>` for the user to confirm + sign in their browser wallet |
+| `pnl_pitch_now` | Autosign | Pin metadata, build + sign the `create_market` tx locally, persist via sig-auth. One shot, no browser |
+| `pnl_vote` | Deep-link | Return `pnl.market/market/<id>?vote=&amount=` deep-link for the user to sign in browser |
+| `pnl_vote_now` | Autosign | Build + sign the `buy_yes` / `buy_no` tx locally for stakes under the cap |
+
+### Trust model
+
+The MCP server holds an encrypted keypair on the local disk. The
+passphrase is never delivered through the agent's chat transcript —
+it comes from `PNL_PASSPHRASE` (set in your MCP host config) or an
+OS-native dialog. Cached secrets time out automatically and on
+`pnl_lock`.
+
+Autosign is bounded by the **autosign cap** (defaults 0.05 SOL),
+configurable via `pnl_unlock`'s output or by editing
+`~/.config/pnl/config.json`. Per-call override available via
+`autosignCapSol`. Anything above the cap requires the deep-link
+flow — by design.
+
+PNL's non-custodial framing in the
+[regulatory posture](https://docs.pnl.market/docs/transparency/regulatory-posture)
+section is load-bearing — the MCP only signs with keys the user
+controls on their own machine.
+
+## Install
+
+### One-shot installer (recommended)
+
+After `pnpm install && pnpm -F @pnlmarket/mcp-server build`:
+
+```bash
+npx @pnlmarket/mcp-server install --write
+```
+
+That wires the MCP server into every supported host config it
+finds on the machine (Claude Code, Cursor, Cline, Codex, Windsurf)
+and copies the 13 slash-command skills into
+`~/.claude/skills/`.
+
+Run without `--write` first to see the plan. Flags:
+
+- `--skills` — only install the slash commands, skip MCP config writes
+- `--no-skills` — skip slash commands, only wire MCP servers
+
+### Manual
+
+The compiled entry point is `apps/mcp/dist/index.js`.
+
+```json
+{
+  "mcpServers": {
+    "pnl": {
+      "command": "node",
+      "args": ["/absolute/path/to/pnl/apps/mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+## Slash commands (Claude Code)
+
+The installer drops these into `~/.claude/skills/`:
+
+```
+/pnl-help            /pnl-browse          /pnl-name
+/pnl-init            /pnl-pitch           /pnl-restore
+/pnl-wallet          /pnl-pitch-now       /pnl-export
+/pnl-unlock          /pnl-vote
+/pnl-lock            /pnl-vote-now
+```
+
+Each is a small Markdown skill manifest that tells the agent how
+to gather the right context from the conversation and which tool
+to call.
+
+## Environment variables
+
+| Variable | Default | When to override |
+|---|---|---|
+| `PNL_API_BASE_URL` | `https://pnl.market` | Pointing at devnet, staging, or a local Next.js dev server |
+| `PNL_RPC_URL` | `https://pnl.market/api/mcp/rpc` (hosted proxy) | BYO Helius key (recommended for heavy use — grab one at [helius.dev](https://helius.dev) and set this to your endpoint) |
+| `PNL_PASSPHRASE` | (prompt via OS dialog) | Skip the OS-native unlock prompt — useful when running an agent unattended, but only set this in your MCP host config, never in shell history |
+
+The default RPC is the hosted proxy. It works zero-setup; under
+load it's rate-limited to 60 reads/min and 10 sends/min per IP.
+Set `PNL_RPC_URL` to your own Helius endpoint to bypass that.
+
+## Try it
+
+Once wired into your agent:
+
+> "What's live on PNL right now?"
+
+Triggers `pnl_browse_markets` — active markets with YES%, pool size,
+vote counts, clickable URLs.
+
+> "Set me up on PNL"
+
+The agent walks `pnl_init` (mnemonic + passphrase), funds-the-wallet
+hint, `pnl_unlock`, `pnl_set_username`.
+
+> "Pitch this idea on PNL and sign it for me"
+
+If the wallet is unlocked and the creation fee fits the autosign
+cap, the agent calls `pnl_pitch_now` and the market is live in
+~10s — no browser bounce. Otherwise it falls back to `pnl_pitch_idea`
+(deep-link).
+
+> "Stake 0.02 YES on the Nakshatra market"
+
+Same shape — `pnl_vote_now` if within cap, `pnl_vote` if not.
+
+## Wallet file layout
+
+```
+~/.config/pnl/
+├── wallet.enc          # encrypted secret + metadata (mode 0600)
+├── config.json         # autosign cap + RPC URL (mode 0644)
+└── exports/            # timestamped backup dumps (mode 0700)
+```
+
+Crypto: scrypt (N=2^17, r=8, p=1) → AES-256-GCM. BIP39 12-word
+mnemonic at the Phantom-compatible derivation path
+`m/44'/501'/0'/0'` so backups import cleanly into
+Phantom / Solflare / Backpack and vice versa.
+
+## Backend surface
+
+The MCP autosign flows talk to four sig-auth-aware endpoints on
+pnl.market:
+
+```
+POST /api/mcp/rpc                            JSON-RPC proxy → Helius
+POST /api/mcp/markets/build-create-tx        unsigned create_market tx
+POST /api/mcp/markets/complete-create        sig-auth → persist Project + Market
+POST /api/mcp/markets/build-vote-tx          unsigned buy_yes / buy_no tx
+POST /api/mcp/markets/complete-vote          sig-auth → persist TradeHistory + counts
+POST /api/mcp/profile                        sig-auth → username claim/rename
+```
+
+The challenge format is canonical:
+`pnl-mcp:<kind>:<fingerprint>:<nonce>` where `<kind>` is one of
+`complete-create | complete-vote | profile`, `<fingerprint>` is
+either the tx signature (for complete-*) or the username (for
+profile), and `<nonce>` is `<unix-ms>-<hex>` with a 5min freshness
+window + 1min clock-skew tolerance. The MCP signs with the local
+keypair; the backend verifies the signature is good for the
+claimed wallet via tweetnacl.
+
+## Links
+
+- Live: [pnl.market](https://pnl.market)
+- Docs: [docs.pnl.market](https://docs.pnl.market) (manifesto + transparency + public API reference)
+- Repo: [github.com/aitankfish/pnl](https://github.com/aitankfish/pnl)
+- Manifesto: [docs.pnl.market/docs/manifesto](https://docs.pnl.market/docs/manifesto)
+
+## License
+
+MIT.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// @pnlmarket/mcp-server — Model Context Protocol server for PNL.
+//
+// Lets agents (Claude Code, Cursor, Cline, Codex, the next one) browse
+// the live conviction-market state on pnl.market and — in later versions
+// — prepare new pitches and votes the user signs in their own wallet.
+//
+// Critical: this server NEVER holds keys. Read tools are pure fetches
+// against the public API. Write-prep tools (coming next) return deep-
+// links to pnl.market; the user always confirms the signature in their
+// own wallet.
+//
+// Transport: stdio. That's the standard for Claude Code / Cursor / Cline.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { browseMarketsInputSchema, callBrowseMarkets } from './tools/browse-markets.js';
+import { getMarketInputSchema, callGetMarket } from './tools/get-market.js';
+import { initInputSchema, callInit } from './tools/init.js';
+import { walletInputSchema, callWallet } from './tools/wallet.js';
+import { exportKeypairInputSchema, callExportKeypair } from './tools/export-keypair.js';
+import { pitchIdeaInputSchema, callPitchIdea } from './tools/pitch-idea.js';
+import { setUsernameInputSchema, callSetUsername } from './tools/set-username.js';
+import { unlockInputSchema, callUnlock, lockInputSchema, callLock } from './tools/unlock.js';
+import { restoreInputSchema, callRestore } from './tools/restore.js';
+import { helpInputSchema, callHelp } from './tools/help.js';
+import { voteInputSchema, callVote } from './tools/vote.js';
+import { pitchNowInputSchema, callPitchNow } from './tools/pitch-now.js';
+import { voteNowInputSchema, callVoteNow } from './tools/vote-now.js';
+import { claimInputSchema, callClaim } from './tools/claim.js';
+import { claimNowInputSchema, callClaimNow } from './tools/claim-now.js';
+import { notifyInputSchema, callNotify } from './tools/notify.js';
+import { runInstall } from './install.js';
+const SERVER_NAME = 'pnl-mcp-server';
+const SERVER_VERSION = '0.4.0';
+// CLI dispatch — when invoked as `pnl-mcp-server install`, run the
+// installer that wires this server into the user's agent configs and
+// drops the slash-command skills into ~/.claude/skills/. Otherwise
+// (the case the agent runtime hits) start the stdio MCP server.
+async function maybeRunCli() {
+    const subcommand = process.argv[2];
+    if (subcommand === 'install') {
+        const code = await runInstall(process.argv.slice(2));
+        process.exit(code);
+    }
+    return false;
+}
+async function main() {
+    const server = new McpServer({ name: SERVER_NAME, version: SERVER_VERSION }, {
+        // We only register tools today. Resources / prompts come later
+        // alongside the write-prep tools.
+        capabilities: { tools: {} },
+    });
+    server.tool('pnl_help', "Show the PNL command reference with every available tool, what it does, and a typical first-run flow. Context-aware — adjusts the suggested next step based on whether the user has a wallet and whether it's unlocked. Use this when the user types '/pnl-help', says 'how do I use PNL', or asks what's possible.", helpInputSchema, async (args) => callHelp(args));
+    server.tool('pnl_browse_markets', "List live conviction markets on PNL. Use this when the user asks 'what's on PNL right now?' or wants to see active idea markets. Returns market names, current YES%, total pool, vote counts, and a URL for each. Filter by status (active, yesWins, noWins, expired, refund, all). Paginate with page+limit.", browseMarketsInputSchema, async (args) => callBrowseMarkets(args));
+    server.tool('pnl_get_market', 'Fetch one market by id (from pnl_browse_markets) or by on-chain market address. Returns the full market state — name, founder, description, YES%, pool sizes, expiry, on-chain address. Use this after pnl_browse_markets when the user wants details on a specific market.', getMarketInputSchema, async (args) => callGetMarket(args));
+    server.tool('pnl_init', 'First-run setup. Generates a local Solana keypair on this machine (stored at ~/.config/pnl/keypair.json, mode 0600) and returns the deposit address. Call this when the user wants to set up PNL on a new machine or asks "how do I get started with PNL?". Idempotent — if a keypair already exists, returns the existing wallet info.', initInputSchema, async (args) => callInit(args));
+    server.tool('pnl_wallet', "Show the local PNL wallet's address and current SOL balance. Read-only. Call this any time the user asks 'what's my PNL wallet?', 'how much SOL do I have?', or to check whether their funding transaction has landed.", walletInputSchema, async (args) => callWallet(args));
+    server.tool('pnl_export_keypair', "Reveal the local PNL secret key in base58 (Phantom-import format) and JSON-array (Solana CLI format). Requires confirm: 'EXPORT' to prevent accidental disclosure. Use only when the user explicitly asks to back up their key, move their wallet to Phantom/Solflare/etc., or migrate to another machine.", exportKeypairInputSchema, async (args) => callExportKeypair(args));
+    server.tool('pnl_pitch_idea', "Pitch a new idea to PNL as a conviction market. The agent supplies the name, description, ticker symbol, category/type/stage, team size, target pool in SOL, duration in days, and optional provenance (the conversation excerpt + code snippet that birthed the idea). Returns a /create?draft=<id> deep-link the user opens in their browser to confirm + sign the create_market transaction in their own wallet. v0.2 is deep-link only -- v0.3 will add local autosigning for under-cap transactions. Use this when the user says 'pitch this on PNL', 'plant this idea', or similar.", pitchIdeaInputSchema, async (args) => callPitchIdea(args));
+    server.tool('pnl_unlock', "Unlock the local PNL wallet for signing. Pulls the passphrase from the PNL_PASSPHRASE env var (set in Claude Code mcp config) or pops an OS-native dialog (osascript on macOS, zenity on Linux). The passphrase NEVER comes from tool arguments and never enters the chat transcript. Caches the unlocked secret in memory for ttl_minutes (default 5, max 60). Re-call to refresh the TTL. Call this before any signing tool: pnl_set_username, pnl_export_keypair, future write-prep tools.", unlockInputSchema, async (args) => callUnlock(args));
+    server.tool('pnl_lock', 'Lock the local PNL wallet immediately. Wipes the cached secret from memory, future signing operations require a fresh pnl_unlock. Use this when stepping away from the machine or after a sensitive session.', lockInputSchema, async (args) => callLock(args));
+    server.tool('pnl_restore', "Restore a PNL wallet on this machine from a BIP39 mnemonic (12 or 24 words). Use when setting up PNL on a new machine and the user already has the recovery phrase from a previous pnl_init. The mnemonic is the standard format Phantom / Solflare / Backpack / Solana CLI all accept. Refuses to overwrite an existing wallet unless allowOverwrite: true is passed. Passphrase is read from PNL_PASSPHRASE env or via OS dialog.", restoreInputSchema, async (args) => callRestore(args));
+    server.tool('pnl_vote', "Stake YES or NO on an existing PNL market. Returns a deep-link URL with the side + amount pre-filled — the user opens it in their browser, confirms the vote panel (already populated), and signs the buy_yes / buy_no transaction with their wallet. Use this when the user says 'vote yes on X', 'fade Y', 'back the AutoImport CLI market', or similar. Phase B will add a local-signing variant for stakes under the autosign cap.", voteInputSchema, async (args) => callVote(args));
+    server.tool('pnl_pitch_now', "Autosign create_market. Same payload as pnl_pitch_idea (name, description, ticker, category, type, stage, team size, target pool, duration), but the MCP signs the create_market transaction locally with the encrypted-at-rest keypair and persists the market without bouncing through the browser. The wallet must be unlocked (pnl_unlock) and the creation fee (~0.015 SOL) must be within the autosign cap (defaults 0.05 SOL, overridable per-call via autosignCapSol). Returns the live market URL + tx signature. Use this when the user says 'pitch this on PNL and sign it for me', 'auto-create the market', or after pnl_pitch_idea when they say 'just do it'.", pitchNowInputSchema, async (args) => callPitchNow(args));
+    server.tool('pnl_vote_now', "Autosign buy_yes / buy_no. Same shape as pnl_vote (marketId + side + amountSol) but the MCP signs the vote transaction locally and persists the trade without bouncing through the browser. Requires an unlocked wallet and the stake to be within the autosign cap (defaults 0.05 SOL, overridable per-call). Returns the on-chain tx signature + Solscan link. Use this when the user says 'vote yes on X for me', 'stake 0.02 NO on the AutoImport market', or similar autonomous-vote intent. For larger stakes, fall back to pnl_vote (deep-link).", voteNowInputSchema, async (args) => callVoteNow(args));
+    server.tool('pnl_claim', "Claim rewards on a resolved PNL market in deep-link mode. Returns a /market/<id>?claim=1 URL — the market detail page opens the claim panel and the user signs the claim_rewards tx in their browser wallet. The market must be resolved (YES wins, NO wins, or refund) and the wallet must have an unclaimed position on it. For autosign (no browser), use pnl_claim_now. Use when the user says 'claim my rewards on X', 'claim YES wins on AutoImport', or after a market the user voted on has resolved.", claimInputSchema, async (args) => callClaim(args));
+    server.tool('pnl_claim_now', "Autosign claim_rewards. Same arg as pnl_claim (marketId). The MCP fetches the on-chain market + position state, builds the claim_rewards tx (with Token2022 ATA creation for YES wins), signs locally with the encrypted-at-rest keypair, sends, and persists. No autosign cap — claiming is a withdrawal of funds the user is already owed, not a spend. Wallet must be unlocked (pnl_unlock). Returns the on-chain tx + Solscan link + profile URL. Use when the user says 'claim it for me' or 'auto-claim X' on a resolved market.", claimNowInputSchema, async (args) => callClaimNow(args));
+    server.tool('pnl_notify', "Show recent notifications for the local PNL wallet — votes on markets you created, resolutions, claim-ready alerts, milestones. Stateful: tracks last-seen on disk so successive calls only show new items (pass all: true to override). Includes a clickable link to the user's PNL profile at /profile/<wallet>. Use when the user says 'what's new on PNL', 'any updates', 'check notifications', or invokes /pnl-notify. No wallet unlock needed (read-only).", notifyInputSchema, async (args) => callNotify(args));
+    server.tool('pnl_set_username', "Claim or rename the PNL username for the local wallet. Signs a time-bounded challenge with the keypair from pnl_init so the backend can verify wallet ownership -- no Privy session or Gmail login required. Usernames are 3-20 characters of letters/numbers/_/-. Returns 'taken' if another wallet has claimed the name. Use when the user says 'set my PNL username to X', 'rename my PNL profile', or after pnl_init when they want a custom name instead of the auto-generated Cosmic one.", setUsernameInputSchema, async (args) => callSetUsername(args));
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Stdio transport keeps the process alive while the host (Claude Code /
+    // Cursor / etc.) holds the pipe. No need to log anything to stdout —
+    // stdout is the MCP message channel. stderr is fine for diagnostics.
+    process.stderr.write(`[${SERVER_NAME}@${SERVER_VERSION}] ready · ${process.env.PNL_API_BASE_URL || 'https://pnl.market'}\n`);
+}
+(async () => {
+    await maybeRunCli();
+    await main();
+})().catch((err) => {
+    process.stderr.write(`[${SERVER_NAME}] fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/install.d.ts

@@ -0,0 +1 @@
+export declare function runInstall(argv: string[]): Promise<number>;

package/dist/install.js

@@ -0,0 +1,168 @@
+// ─── pnl-mcp-server install ──────────────────────────────────────
+//
+// One-shot installer that wires @pnlmarket/mcp-server into the user's agent
+// of choice (Claude Code, Cursor, Cline) and optionally drops the
+// SKILL.md slash commands into their skills directory.
+//
+// Usage:
+//   npx @pnlmarket/mcp-server install            # prints plan, asks for confirm
+//   npx @pnlmarket/mcp-server install --write    # apply without confirmation
+//   npx @pnlmarket/mcp-server install --skills   # only install slash commands
+//
+// Idempotent: re-running is safe. Existing entries get replaced
+// in-place, no duplicates accumulate.
+import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const SERVER_KEY = 'pnl';
+const NPX_COMMAND = 'npx';
+const NPX_ARGS = ['-y', '@pnlmarket/mcp-server'];
+function candidates() {
+    const home = homedir();
+    return [
+        {
+            label: 'Claude Code CLI',
+            configPath: join(home, '.claude.json'),
+            description: 'The Claude Code terminal app reads MCP servers from here.',
+        },
+        {
+            label: 'Claude Desktop (macOS)',
+            configPath: join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+            description: 'The desktop app on macOS.',
+        },
+        {
+            label: 'Cursor',
+            configPath: join(home, '.cursor', 'mcp.json'),
+            description: 'Cursor MCP config.',
+        },
+    ];
+}
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeJson(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n');
+}
+function ensureMcpServer(config) {
+    const existing = config.mcpServers ?? {};
+    const current = existing[SERVER_KEY];
+    const matches = current?.command === NPX_COMMAND &&
+        Array.isArray(current.args) &&
+        current.args.length === NPX_ARGS.length &&
+        current.args.every((a, i) => a === NPX_ARGS[i]);
+    if (matches) {
+        return { changed: false, existingMatches: true };
+    }
+    config.mcpServers = {
+        ...existing,
+        [SERVER_KEY]: { command: NPX_COMMAND, args: NPX_ARGS },
+    };
+    return { changed: true, existingMatches: false };
+}
+function installSkills() {
+    const targetDir = join(homedir(), '.claude', 'skills');
+    mkdirSync(targetDir, { recursive: true });
+    // The skills directory ships alongside the npm tarball. From dist/,
+    // that's ../skills.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const skillsRoot = join(here, '..', 'skills');
+    if (!existsSync(skillsRoot)) {
+        return { copied: 0, targetDir };
+    }
+    let copied = 0;
+    for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.startsWith('pnl-'))
+            continue;
+        const src = join(skillsRoot, entry.name);
+        const dest = join(targetDir, entry.name);
+        // cpSync with recursive overwrite — re-running the installer just
+        // refreshes the templates with whatever the current package ships.
+        cpSync(src, dest, { recursive: true, force: true });
+        copied++;
+    }
+    return { copied, targetDir };
+}
+function logBlock(title, body) {
+    process.stdout.write(`\n── ${title} ──\n${body}\n`);
+}
+export async function runInstall(argv) {
+    const flags = new Set(argv.slice(1));
+    const write = flags.has('--write') || flags.has('-y') || flags.has('--yes');
+    const skillsOnly = flags.has('--skills');
+    const noSkills = flags.has('--no-skills');
+    process.stdout.write('\n@pnlmarket/mcp-server installer\n');
+    // 1. Discover target configs.
+    const targets = candidates();
+    const present = targets.filter((t) => existsSync(t.configPath));
+    const missing = targets.filter((t) => !existsSync(t.configPath));
+    if (skillsOnly) {
+        const { copied, targetDir } = installSkills();
+        process.stdout.write(`\nSlash commands installed: ${copied} skill${copied === 1 ? '' : 's'} -> ${targetDir}\n`);
+        process.stdout.write('Restart Claude Code, then type /pnl-init to begin.\n');
+        return 0;
+    }
+    const planLines = [];
+    if (present.length === 0) {
+        planLines.push('No agent config files found at the standard locations.');
+        planLines.push('You can still run the server directly. After installing globally with `npm i -g @pnlmarket/mcp-server`, add this to your agent\'s MCP config:');
+        planLines.push('');
+        planLines.push(JSON.stringify({ mcpServers: { [SERVER_KEY]: { command: NPX_COMMAND, args: NPX_ARGS } } }, null, 2));
+    }
+    else {
+        planLines.push('Will add an `mcpServers.pnl` entry pointing to `npx -y @pnlmarket/mcp-server` in:');
+        for (const t of present) {
+            planLines.push(`  • ${t.label}: ${t.configPath}`);
+        }
+        if (missing.length) {
+            planLines.push('');
+            planLines.push('Not found (skipped):');
+            for (const t of missing) {
+                planLines.push(`  • ${t.label}: ${t.configPath}`);
+            }
+        }
+    }
+    if (!noSkills) {
+        planLines.push('');
+        planLines.push(`Will also copy the slash-command skills (pnl-init, pnl-wallet, pnl-unlock, pnl-lock, pnl-restore, pnl-export, pnl-name, pnl-browse, pnl-pitch, pnl-pitch-now, pnl-vote, pnl-vote-now, pnl-claim, pnl-claim-now, pnl-notify, pnl-help) to ~/.claude/skills/`);
+    }
+    logBlock('Plan', planLines.join('\n'));
+    if (!write) {
+        process.stdout.write('\nRe-run with `--write` (or `-y`) to apply.\n  npx @pnlmarket/mcp-server install --write\n\n');
+        return 0;
+    }
+    // 2. Apply.
+    let mcpWritten = 0;
+    let mcpAlready = 0;
+    for (const target of present) {
+        const config = readJson(target.configPath);
+        const { changed, existingMatches } = ensureMcpServer(config);
+        if (existingMatches) {
+            mcpAlready++;
+            continue;
+        }
+        if (changed) {
+            writeJson(target.configPath, config);
+            mcpWritten++;
+        }
+    }
+    const skillsResult = !noSkills ? installSkills() : null;
+    logBlock('Done', [
+        `MCP server entries written: ${mcpWritten}${mcpAlready ? ` (${mcpAlready} already current)` : ''}`,
+        skillsResult
+            ? `Slash commands installed: ${skillsResult.copied} skill${skillsResult.copied === 1 ? '' : 's'} -> ${skillsResult.targetDir}`
+            : 'Slash commands: skipped (--no-skills)',
+        '',
+        'Next:',
+        '  1. Restart Claude Code / Cursor.',
+        '  2. Type /pnl-init in any session — it generates a local Solana keypair and shows the deposit address.',
+        '  3. Fund the wallet with at least 0.05 SOL from any Solana wallet, then /pnl-pitch an idea.',
+    ].join('\n'));
+    return 0;
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Shorten a base58 pubkey for display. Keeps the first 6 and last 4
+ * characters — enough to be visually distinguishable without taking
+ * a full line.
+ *
+ *   truncAddress("9ot5o7tbtUit8j75ivdjxoUCGaY7uCcUDootdKuVhECH")
+ *   // → "9ot5o7…hECH"
+ */
+export declare function truncAddress(addr: string, leading?: number, trailing?: number): string;
+/**
+ * Format SOL from lamports with reasonable precision. Returns null
+ * when the amount is below display threshold so callers can omit
+ * the row entirely.
+ */
+export declare function formatSol(lamports: number | string | null | undefined): string | null;
+export declare const Badge: {
+    readonly ok: "[ok]";
+    readonly warn: "[!]";
+    readonly err: "[err]";
+    readonly locked: "[locked]";
+    readonly unlocked: "[unlocked]";
+    readonly live: "[live]";
+    readonly ended: "[ended]";
+    readonly pending: "[pending]";
+    readonly draft: "[draft]";
+};
+/**
+ * Render a one-line bold "headline" answer. The user can read just
+ * this and stop. Subsequent text is "if you want details".
+ */
+export declare function headline(text: string): string;
+/**
+ * Two-column key/value table. Used by pnl_wallet, pnl_get_market,
+ * etc. for structured "here's what we know" responses.
+ */
+export declare function kvTable(rows: Array<[string, string | null | undefined]>): string;
+/**
+ * Generic markdown table with headers + rows. Pads cells with one
+ * space on each side so the source reads cleanly in case the user
+ * is on a renderer that doesn't pretty-print markdown tables.
+ */
+export declare function table(headers: string[], rows: string[][]): string;
+/**
+ * Code block — useful for pubkeys, tx signatures, IPFS CIDs,
+ * mnemonics, file paths. Claude Code renders these as monospace
+ * with a copy button.
+ */
+export declare function code(content: string, lang?: string): string;
+/**
+ * Inline code span — for short identifiers in the middle of a
+ * sentence.
+ */
+export declare function inline(content: string): string;
+/**
+ * Blockquote — used for market descriptions, manifesto-style
+ * pull-quotes, important warnings.
+ */
+export declare function quote(text: string): string;
+/**
+ * Markdown heading — H3 by default since tool output isn't a doc.
+ */
+export declare function heading(text: string, level?: 1 | 2 | 3 | 4): string;
+/**
+ * Horizontal rule. Use sparingly to separate big sections.
+ */
+export declare const hr = "---";
+/**
+ * Action hint at the bottom of an output. Standardized so users
+ * recognize the pattern.
+ */
+export declare function next(hint: string): string;
+/**
+ * Wrap a tool result in the MCP content-block shape so callers
+ * don't have to repeat the boilerplate. Joins parts with two
+ * newlines so each section gets a paragraph break.
+ */
+export declare function reply(...parts: Array<string | null | undefined | false>): {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+};
+/**
+ * Render a Solana address: truncated for the eye, plus a code block
+ * with the full thing for copy. Optionally include a Solscan link.
+ */
+export declare function addressBlock(addr: string, opts?: {
+    label?: string;
+    solscan?: boolean;
+}): string;
+/**
+ * Render a market URL with its truncated id and the full URL on a
+ * separate line for copy.
+ */
+export declare function marketLink(marketId: string, baseUrl: string): string;