@pnlmarket/mcp-server 0.4.0

package/dist/tools/vote-now.js

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import { PublicKey } from '@solana/web3.js';
+import { requireUnlockedKeypair, loadConfig, getConnection, getBalanceSol, } from '../lib/wallet.js';
+import { signSerializedTx, sendAndConfirm, freshNonce, signChallenge, challenge, signedRequestHash, } from '../lib/sign.js';
+import { getMarket } from '../lib/pnl-api.js';
+import { Badge, headline, code, kvTable, inline, next, reply, hr } from '../lib/output.js';
+// ─── pnl_vote_now ────────────────────────────────────────────────
+//
+// Autosign buy_yes / buy_no. Same shape as pnl_pitch_now: build the
+// unsigned tx server-side, sign + send locally, sig-auth complete-vote
+// to write trade history + bump participant counts.
+export const voteNowInputSchema = {
+    marketId: z
+        .string()
+        .min(1)
+        .describe('Market id from pnl_browse_markets or pnl_get_market. Accepts either the Mongo id or the on-chain market address — we resolve to the on-chain address internally.'),
+    vote: z
+        .enum(['yes', 'no'])
+        .describe("'yes' to back the idea, 'no' to fade it. NO voters split the pool if NO wins."),
+    amountSol: z
+        .number()
+        .positive()
+        .describe('Stake in SOL. Minimum 0.01 SOL. Total cost is amount + ~0.000005 SOL Solana tx fee.'),
+    autosignCapSol: z
+        .number()
+        .positive()
+        .optional()
+        .describe('Optional cap override that can only LOWER the autosign limit for this call, never raise it. Ceiling is from ~/.config/pnl/config.json (default 0.05 SOL). Stakes above the (lowered) cap fail before any signing — use pnl_vote for the deep-link flow in that case.'),
+};
+const VoteNowInput = z.object(voteNowInputSchema);
+function getApiBase() {
+    const raw = process.env.PNL_API_BASE_URL?.trim();
+    if (!raw)
+        return 'https://pnl.market';
+    return raw.endsWith('/') ? raw.slice(0, -1) : raw;
+}
+export async function callVoteNow(rawInput) {
+    const input = VoteNowInput.parse(rawInput ?? {});
+    // Cap check before any I/O. The user's stake itself is the dominant
+    // cost — Solana tx fees are ~5000 lamports (0.000005 SOL).
+    //
+    // Cap policy: the user's configured cap is the ceiling — the
+    // per-call autosignCapSol arg can only LOWER it, never raise.
+    // To raise the cap the user edits ~/.config/pnl/config.json directly.
+    const configCap = loadConfig().autosignCapSol;
+    const cap = input.autosignCapSol != null
+        ? Math.min(input.autosignCapSol, configCap)
+        : configCap;
+    if (input.amountSol > cap) {
+        throw new Error(`Stake ${input.amountSol} SOL exceeds autosign cap ${cap} SOL. Either raise the cap (autosignCapSol arg) or use pnl_vote for the browser deep-link flow.`);
+    }
+    const keypair = requireUnlockedKeypair();
+    const walletAddress = keypair.publicKey.toBase58();
+    const base = getApiBase();
+    // Resolve marketId → on-chain address. The user-facing arg accepts
+    // either the Mongo id (returned by pnl_browse_markets) or the
+    // already-base58 market address; the on-chain build needs the
+    // latter. /api/markets/<id> returns both so we can be flexible.
+    let marketAddress;
+    let onchainId;
+    try {
+        new PublicKey(input.marketId);
+        marketAddress = input.marketId;
+        onchainId = input.marketId; // assume the user supplied the on-chain one
+        // For the complete-vote call we still want the Mongo id (it's what
+        // /market/<id> uses + how participants are keyed). Look it up.
+        const market = await getMarket(input.marketId);
+        onchainId = market.id ?? input.marketId;
+    }
+    catch {
+        // Not a valid base58 pubkey — treat as Mongo id.
+        const market = await getMarket(input.marketId);
+        if (!market.marketAddress) {
+            throw new Error(`market ${input.marketId} has no marketAddress — cannot autosign vote`);
+        }
+        marketAddress = market.marketAddress;
+        onchainId = market.id ?? input.marketId;
+    }
+    // Balance sanity-check.
+    const balance = await getBalanceSol(new PublicKey(walletAddress));
+    const required = input.amountSol + 0.001; // stake + comfortable tx-fee buffer
+    if (balance < required) {
+        throw new Error(`Wallet balance ${balance.toFixed(4)} SOL is below the ${required.toFixed(4)} SOL needed (stake + fee buffer). Fund ${walletAddress} and try again.`);
+    }
+    // 1. build-vote-tx
+    const buildRes = await fetch(`${base}/api/mcp/markets/build-vote-tx`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({
+            walletAddress,
+            marketAddress,
+            voteType: input.vote,
+            amountSol: input.amountSol,
+        }),
+    });
+    const buildJson = (await buildRes.json());
+    if (!buildRes.ok || !buildJson.success || !buildJson.data) {
+        throw new Error(`build-vote-tx failed (${buildRes.status}): ${buildJson.error || 'unknown error'}`);
+    }
+    const built = buildJson.data;
+    // 2. sign + send locally
+    const rawTx = signSerializedTx(built.tx, keypair);
+    const { signature: txSignature } = await sendAndConfirm(rawTx, getConnection(), {
+        confirmTimeoutMs: 90_000,
+    });
+    // 3. Build complete-vote body, hash it into the challenge, sign.
+    //    The hash binds the sig to voteType + amountSol + marketId so an
+    //    attacker who captures the sig within the nonce window cannot
+    //    rewrite the side or amount on the persisted trade row.
+    const nonce = freshNonce();
+    const completeBodyCore = {
+        txSignature,
+        marketId: onchainId,
+        voteType: input.vote,
+        amountSol: input.amountSol,
+    };
+    const payloadHash = signedRequestHash(completeBodyCore);
+    const sig = signChallenge(challenge('complete-vote', txSignature, nonce, payloadHash), keypair);
+    const completeRes = await fetch(`${base}/api/mcp/markets/complete-vote`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: JSON.stringify({
+            walletAddress,
+            nonce,
+            signature: sig,
+            ...completeBodyCore,
+        }),
+    });
+    const completeJson = (await completeRes.json());
+    if (!completeRes.ok || !completeJson.success || !completeJson.data) {
+        throw new Error(`Tx confirmed on-chain (${txSignature}) but complete-vote failed (${completeRes.status}): ${completeJson.error || 'unknown error'}. The on-chain vote is recorded — re-running pnl_vote_now with the same args is idempotent on the tx signature.`);
+    }
+    const done = completeJson.data;
+    const side = input.vote === 'yes' ? 'YES' : 'NO';
+    const sideHint = input.vote === 'yes'
+        ? '(backing the idea)'
+        : "(fading the idea — split the pool with other critics if NO wins)";
+    return reply(headline(`${Badge.live} ${side} ${input.amountSol} SOL recorded`), kvTable([
+        ['Market', `${base}/market/${onchainId}`],
+        ['Side', `${side} ${sideHint}`],
+        ['Stake', `${input.amountSol} SOL`],
+        ['Wallet', inline(walletAddress)],
+        ['Tx', `[${txSignature.slice(0, 8)}…${txSignature.slice(-6)}](${done.solscan})`],
+        done.alreadyExists ? ['Note', 'idempotent retry — vote was already recorded'] : null,
+    ].filter((r) => Array.isArray(r))), hr, `The MCP signed and sent the \`buy_${input.vote}\` transaction locally — no browser bounce needed because the stake (${input.amountSol} SOL) was within the autosign cap (${cap} SOL).`, code(`Tx: ${txSignature}`), next(`Check pool movement at ${inline(`${base}/market/${onchainId}`)}.`));
+}

package/dist/tools/vote.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const voteInputSchema: {
+    readonly marketId: z.ZodString;
+    readonly vote: z.ZodEnum<["yes", "no"]>;
+    readonly amountSol: z.ZodNumber;
+};
+export declare function callVote(rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/vote.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { Badge, headline, code, kvTable, next, reply } from '../lib/output.js';
+// ─── pnl_vote ────────────────────────────────────────────────────
+//
+// Prepare a YES/NO stake on an existing market and return a deep-link
+// URL with ?vote=<side>&amount=<sol> query params. The market detail
+// page reads those on mount and pre-fills the vote panel — the user
+// confirms + signs in their browser wallet.
+//
+// Like pnl_pitch_idea, v0.2 is deep-link only. Phase B autosign will
+// build + sign the buy_yes / buy_no transaction locally for stakes
+// under the autosign cap.
+export const voteInputSchema = {
+    marketId: z
+        .string()
+        .min(1)
+        .describe("The market id from pnl_browse_markets or pnl_get_market. Either the Mongo document id or the on-chain market address works."),
+    vote: z
+        .enum(['yes', 'no'])
+        .describe("'yes' to back the idea (you think it deserves to launch). 'no' to fade it (you think it won't / shouldn't). NO voters split the pool if NO wins — they get paid for filtering noise."),
+    amountSol: z
+        .number()
+        .positive()
+        .describe("How much SOL to stake. Minimum 0.01 SOL on most markets. Typical range 0.01-1 SOL for retail-sized votes."),
+};
+const VoteInput = z.object(voteInputSchema);
+function getApiBase() {
+    const raw = process.env.PNL_API_BASE_URL?.trim();
+    if (!raw)
+        return 'https://pnl.market';
+    return raw.endsWith('/') ? raw.slice(0, -1) : raw;
+}
+export async function callVote(rawInput) {
+    const { marketId, vote, amountSol } = VoteInput.parse(rawInput ?? {});
+    // We trust the market id format and let the live page validate
+    // existence — no point hitting /api/markets/<id> here just to fail
+    // before the user opens the link.
+    const base = getApiBase();
+    const url = `${base}/market/${encodeURIComponent(marketId)}?vote=${vote}&amount=${amountSol}`;
+    const side = vote === 'yes' ? 'YES' : 'NO';
+    const sideHint = vote === 'yes'
+        ? "(backing the idea — you think it deserves to launch)"
+        : "(fading the idea — you'll split the pool with other critics if NO wins)";
+    return reply(headline(`${Badge.draft} ${side} ${amountSol} SOL on \`${marketId}\``), `Open this URL to confirm and sign in your browser wallet:`, code(url), kvTable([
+        ['Side', `${side} ${sideHint}`],
+        ['Amount', `${amountSol} SOL`],
+        ['Market', `\`${marketId}\``],
+    ]), `The market detail page pre-fills the vote panel from the URL. You'll confirm the side + amount and sign the \`buy_yes\` (or \`buy_no\`) transaction with your wallet (Privy session, or external Phantom if you imported the keypair via \`pnl_export_keypair\`). Transaction confirms in ~5-15s on Solana mainnet.`, next('Open the URL in a browser to sign.'));
+}

package/dist/tools/wallet.d.ts

@@ -0,0 +1,7 @@
+export declare const walletInputSchema: {};
+export declare function callWallet(_rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/wallet.js

@@ -0,0 +1,40 @@
+import { getAddress, getBalanceSol, hasWallet, loadConfig, getRpcUrl, isUsingHostedRpc, unlockStatus, } from '../lib/wallet.js';
+import { PublicKey } from '@solana/web3.js';
+import { Badge, headline, kvTable, inline, truncAddress, next, reply } from '../lib/output.js';
+// ─── pnl_wallet ──────────────────────────────────────────────────
+//
+// Read-only status snapshot. Address (truncated + full), balance,
+// lock state, autosign cap, RPC. Doesn't require unlock.
+export const walletInputSchema = {};
+export async function callWallet(_rawInput) {
+    if (!hasWallet()) {
+        return reply(headline('No PNL wallet on this machine yet.'), `Run ${inline('pnl_init')} to generate one — fresh BIP39 mnemonic, encrypted local keypair, deposit address ready in seconds.`, next(`Type \`/pnl-init\` or ask the agent to set up PNL.`));
+    }
+    const address = getAddress();
+    const config = loadConfig();
+    const { unlocked, secondsRemaining } = unlockStatus();
+    let balance;
+    try {
+        const sol = await getBalanceSol(new PublicKey(address));
+        balance = `${sol.toFixed(4)} SOL`;
+    }
+    catch (e) {
+        balance = `(lookup failed — ${e instanceof Error ? e.message.slice(0, 60) : 'network'})`;
+    }
+    const lockState = unlocked
+        ? `${Badge.unlocked} ${Math.floor(secondsRemaining / 60)}m ${secondsRemaining % 60}s remaining`
+        : `${Badge.locked} — run \`/pnl-unlock\` before signing`;
+    const hosted = isUsingHostedRpc();
+    const rpcLabel = hosted ? `\`${getRpcUrl()}\` (hosted)` : `\`${getRpcUrl()}\``;
+    return reply(headline(`${truncAddress(address)} · ${balance} · ${unlocked ? Badge.unlocked : Badge.locked}`), kvTable([
+        ['Address', `\`${address}\``],
+        ['Balance', balance],
+        ['Status', lockState],
+        ['Autosign cap', `${config.autosignCapSol} SOL`],
+        ['RPC', rpcLabel],
+    ]), hosted
+        ? `_RPC: pnl.market (hosted) — heavy use? Grab a free Helius key at helius.dev and set ${inline('PNL_RPC_URL')} in your Claude Code mcp config to skip the shared rate limit._`
+        : null, unlocked
+        ? next('Pitch an idea with `/pnl-pitch` or vote with `/pnl-vote`.')
+        : next('Run `/pnl-unlock` to enable signing.'));
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@pnlmarket/mcp-server",
+  "version": "0.4.0",
+  "description": "Model Context Protocol server for PNL — let agents (Claude Code, Cursor, Cline, Codex) browse live conviction markets, pitch ideas as markets, and stake YES/NO without leaving the terminal. Local encrypted wallet, autosign for sub-cap amounts, deep-link for larger ones.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "pnl-mcp-server": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pnl",
+    "solana",
+    "prediction-market",
+    "conviction-market",
+    "launchpad",
+    "claude-code",
+    "cursor",
+    "agent"
+  ],
+  "author": "Bishwanath Bastola",
+  "license": "MIT",
+  "homepage": "https://docs.pnl.market/docs/build/mcp-server",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aitankfish/pnl.git",
+    "directory": "apps/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/aitankfish/pnl/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@solana/web3.js": "^1.95.0",
+    "bip39": "^3.1.0",
+    "bs58": "^6.0.0",
+    "ed25519-hd-key": "^1.3.0",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  }
+}

package/skills/README.md

@@ -0,0 +1,45 @@
+# PNL skills for Claude Code
+
+Short slash commands that wrap the `@pnlmarket/mcp-server` tools. Install
+these once and you can type `/pnl-init`, `/pnl-wallet`, `/pnl-browse`,
+`/pnl-pitch`, `/pnl-export` in any Claude Code session instead of
+asking the agent to call MCP tools by name.
+
+## What they do
+
+| Command | What it does | MCP tool it wraps |
+|---|---|---|
+| `/pnl-init` | First-run setup. Generate a local Solana keypair and show the deposit address. | `pnl_init` |
+| `/pnl-wallet` | Show the local wallet's address, balance, autosign cap, RPC. | `pnl_wallet` |
+| `/pnl-browse` | List live conviction markets on PNL with YES%, pool, votes. | `pnl_browse_markets` |
+| `/pnl-pitch` | Pitch an idea from the current conversation. Extracts context, asks the user for missing fields, returns a deep-link to post the market. | `pnl_pitch_idea` |
+| `/pnl-export` | Back up the local keypair (base58 + JSON-array). Requires confirmation. | `pnl_export_keypair` |
+
+## Install
+
+Copy each skill directory into your Claude Code skills folder:
+
+```bash
+# macOS / Linux
+cp -R apps/mcp/skills/pnl-* ~/.claude/skills/
+
+# or, symlink them so updates flow without recopying:
+for d in apps/mcp/skills/pnl-*; do
+  ln -s "$(pwd)/$d" "$HOME/.claude/skills/$(basename "$d")"
+done
+```
+
+Restart Claude Code. The five commands appear in `/help`.
+
+## Prereq
+
+You also need the MCP server itself wired into Claude Code's
+`mcpServers` config. See `apps/mcp/README.md` for that — once the
+server is registered, these skills tell the agent how to use it.
+
+## Customization
+
+Each skill is a single `SKILL.md` with frontmatter (name +
+description) and free-form instructions to the agent. Edit them to
+match your team's pitch style, default target pool, default duration,
+etc. — they're just markdown.

package/skills/pnl-browse/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: pnl-browse
+description: List live conviction markets on PNL. Use to see what ideas are currently open for voting.
+---
+
+# /pnl-browse
+
+The user wants to see what's currently live on PNL — names, YES%,
+pool sizes, vote counts.
+
+## What to do
+
+1. Call the `pnl_browse_markets` MCP tool. Defaults are fine — `status: "active"`,
+   `limit: 10`. If the user said "show me resolved markets" or "what won
+   recently", pass `status: "yesWins"` or `status: "noWins"`.
+2. Display the formatted summary returned by the tool. Each market line
+   shows: name + $ticker + founder, status + YES% + pool + vote count
+   + time-left, and a URL the user can click to see the full market.
+3. If the user wants details on a specific market, suggest they run
+   `/pnl-get <market-id>` (the id is in the URL after `/market/`) or
+   call `pnl_get_market` directly.
+4. Don't repeat the raw JSON dump back to the user unless they ask —
+   it's there for the agent's reasoning, not display.
+
+## Common follow-ups
+
+- "Show me the AI ones" → call again with default args, then filter the
+  results by category in your response.
+- "Just YES%" → re-render with only that field per market.
+- "More" → call again with `page: 2`.

package/skills/pnl-claim/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: pnl-claim
+description: Claim rewards on a resolved PNL market in deep-link mode. Returns a URL the user opens to sign the claim_rewards tx in their browser wallet.
+---
+
+# /pnl-claim
+
+The user has an unclaimed position on a resolved PNL market and
+wants to collect their rewards via the browser flow (no MCP unlock
+needed).
+
+## What to do
+
+### Step 1 — figure out which market
+
+If the user named one or said "claim my market", run
+`pnl_browse_markets` (filter by `status: 'yesWins'`, `'noWins'`, or
+`'refund'`) — or use `pnl_notify` to surface "claim_ready"
+notifications if any are pending.
+
+If the user is talking about their own positions, the
+`/profile/<wallet>` page is the source of truth for what's
+claimable; suggest opening it if disambiguating between several.
+
+### Step 2 — confirm
+
+Quickly check that:
+- The market is resolved (not "active" / "Unresolved")
+- The user expects to be a winner (they had a position on the
+  winning side, or it's a refund)
+
+If anything is off, redirect to `pnl_browse_markets` or the profile
+page rather than guessing.
+
+### Step 3 — call pnl_claim
+
+Pass `{ marketId }`. The tool returns a URL of the form
+`/market/<id>?claim=1`.
+
+### Step 4 — hand off
+
+Tell the user to open the URL — the market detail page detects
+`?claim=1`, opens the claim panel, and they sign `claim_rewards`
+in their browser wallet. Tx confirms in ~5-15s.
+
+## Failure modes
+
+- **Market not resolved**: backend returns 400. Surface as "this
+  market hasn't resolved yet — check back when YES, NO, or refund
+  is decided."
+- **No position**: backend returns 404. Surface as "this wallet has
+  nothing to claim on that market."
+- **Already claimed**: backend returns 400 with "Rewards already
+  claimed for this position".
+
+## When to use `/pnl-claim-now` instead
+
+If the user says "claim it for me" or "auto-claim", switch to
+`/pnl-claim-now` — it signs locally without a browser bounce.
+Requires the wallet to be unlocked.

package/skills/pnl-claim-now/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: pnl-claim-now
+description: Autosign claim_rewards — the MCP signs and sends locally. No browser bounce, no autosign cap (claim is a withdrawal, not a spend).
+---
+
+# /pnl-claim-now
+
+The user wants to collect rewards on a resolved PNL market without
+leaving the terminal. Unlike `/pnl-pitch-now` and `/pnl-vote-now`
+there is no autosign cap — claim is a withdrawal of funds the user
+is already owed by the program, so capping it would gate the user
+from their own money.
+
+## Prerequisites
+
+- Wallet on this machine (`pnl_init` previously)
+- Wallet **unlocked** (`pnl_unlock` first)
+- Market resolved (YES wins, NO wins, or refund) — not Active
+- Wallet has an unclaimed position on the market
+
+## What to do
+
+### Step 1 — figure out which market
+
+`pnl_browse_markets` filtered by status, or `pnl_notify` if there
+are claim-ready notifications, or a marketId the user named
+directly.
+
+### Step 2 — confirm autosign
+
+In one sentence:
+
+> "I'll sign the `claim_rewards` tx locally with your wallet.
+> Confirm?"
+
+If the user wants the browser path, switch to `/pnl-claim`.
+
+### Step 3 — call pnl_claim_now
+
+Pass `{ marketId }`. The tool:
+1. Fetches market resolution + position from chain
+2. Builds the unsigned tx (including Token2022 ATA creation for
+   YES wins)
+3. Signs locally
+4. Sends + confirms
+5. Persists via sig-auth complete-claim
+
+Returns tx signature + Solscan link + profile URL.
+
+### Step 4 — hand off
+
+Tell the user where to see the updated position:
+the `/profile/<wallet>` URL the tool returned. For YES wins, the
+tokens land in the wallet's Token2022 ATA (Phantom / Solflare /
+Backpack will surface them automatically).
+
+## Failure modes
+
+- **Wallet locked** → suggest `/pnl-unlock` first.
+- **Market not resolved** → "this market hasn't resolved yet."
+- **No position** → "this wallet has nothing to claim on that
+  market."
+- **Already claimed** → no-op; suggest checking the profile to see
+  the existing claim.
+- **Tx confirmed but complete-claim failed** → the on-chain claim
+  succeeded; the off-chain "claimed" flag failed to update.
+  Re-running `pnl_claim_now` is safe (idempotent on tx signature).

package/skills/pnl-export/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: pnl-export
+description: Export the local PNL keypair (base58 + JSON-array) so the user can back it up or import it into Phantom/Solflare/Backpack. Requires explicit confirmation.
+---
+
+# /pnl-export
+
+The user wants to back up the seed of their local PNL wallet, or move
+it into a different Solana wallet (Phantom / Solflare / Backpack /
+Solana CLI).
+
+## What to do
+
+1. **Confirm before exporting.** The keypair is the entire access
+   control for the wallet — anyone who reads it can spend the SOL on
+   it. Ask the user something like:
+
+   > "I'm about to show your PNL secret key in this conversation. It
+   > can be used by anyone who sees it to spend your funds. Continue?"
+
+   Only proceed if they say yes.
+
+2. Call the `pnl_export_keypair` MCP tool with `confirm: "EXPORT"`.
+
+3. Display the response. It contains both formats:
+   - **base58 string** — paste into Phantom's "Import Private Key"
+     (also works for Solflare and Backpack)
+   - **64-byte JSON array** — for the Solana CLI
+     (`solana config set --keypair /path/to/keypair.json`)
+
+4. Suggest the user:
+   - Save the base58 string in a password manager (1Password, Bitwarden, etc.)
+   - Clear their terminal scrollback after copying, if they're on a
+     shared machine
+   - Test the restore in a wallet they control before relying on it
+
+5. If the user pastes the secret somewhere visible (a screenshot, a
+   shared chat), warn them to rotate the wallet by sending funds to a
+   fresh `pnl_init`-generated address.

package/skills/pnl-help/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: pnl-help
+description: Show all PNL commands + 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.
+---
+
+# /pnl-help
+
+The user wants to discover what PNL can do from the terminal.
+
+## What to do
+
+1. Call the `pnl_help` MCP tool (no arguments).
+2. Display the response verbatim — it's already formatted as a
+   markdown reference with context-aware suggestions.
+
+That's it. If the user has a follow-up like "what does X do",
+explain it from the table or call the specific tool directly.

package/skills/pnl-init/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: pnl-init
+description: Set up PNL on this machine — generate a local Solana keypair and show the deposit address. Run this once before pitching ideas or voting.
+---
+
+# /pnl-init
+
+First-run setup for PNL. The user wants to start posting ideas to the
+conviction-market protocol on Solana (pnl.market) from their terminal.
+
+## What to do
+
+1. Call the `pnl_init` MCP tool with no arguments.
+2. Relay the response verbatim — it contains the deposit address, current
+   balance, and clear funding instructions.
+3. Suggest the user fund the wallet by sending at least 0.05 SOL from any
+   Solana wallet (Phantom, Solflare, Backpack, an exchange withdrawal).
+4. Tell them once funded they can run `/pnl-wallet` to confirm the balance
+   landed, or `/pnl-pitch <idea>` to post an idea directly.
+
+## Tone
+
+Be direct. Don't editorialize about non-custodial framing unless the user
+asks. The terminal output already says enough.

package/skills/pnl-lock/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: pnl-lock
+description: Lock the PNL wallet immediately. Wipes the cached secret from memory; future signing requires a fresh unlock.
+---
+
+# /pnl-lock
+
+The user wants to lock the PNL wallet right now — stepping away,
+ending a session, or after a sensitive operation.
+
+## What to do
+
+1. Call the `pnl_lock` MCP tool (no arguments).
+2. Confirm the wallet is locked.
+
+This is a fast operation and safe to call any time. If the wallet was
+already locked, the tool just confirms that.

package/skills/pnl-name/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: pnl-name
+description: Claim or rename your PNL username. Signs a challenge with the local wallet to prove ownership — no browser, no Privy, no Gmail login needed.
+---
+
+# /pnl-name
+
+The user wants to set the username shown on their PNL profile and on
+any market detail page they create.
+
+## What to do
+
+1. Ask the user what they'd like the username to be (or extract from
+   their message if they gave it inline — e.g. "/pnl-name bishwa" or
+   "set my pnl username to bishwa"). Constraints: 3-20 characters,
+   letters / numbers / `_` / `-` only.
+2. Call the `pnl_set_username` MCP tool with `{ username: <name> }`.
+3. If the response is "taken", suggest 2-3 variations (e.g. append a
+   number, add `_pnl`, swap an underscore for a hyphen) and ask the
+   user which to try.
+4. On success, relay the confirmation:
+   - new username
+   - wallet address it's attached to
+   - mention that this name will now show on the market detail page
+     for any market they create (replacing the truncated wallet address)
+
+## Common follow-ups
+
+- "Why no Gmail?" → PNL is non-custodial; the wallet IS the login.
+  The MCP server signs a time-bounded challenge with the keypair from
+  pnl_init so the backend can verify ownership without a Privy session.
+- "Can I change it later?" → Yes, just run `/pnl-name <new-name>` again.