@pnlmarket/mcp-server 0.4.0

package/dist/tools/claim.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { getMarket } from '../lib/pnl-api.js';
+import { Badge, headline, code, kvTable, next, reply } from '../lib/output.js';
+// ─── pnl_claim ──────────────────────────────────────────────────
+//
+// Deep-link mode. Returns the /market/<id>?claim=1 URL — the market
+// detail page detects the query param, opens the claim panel, and
+// the user signs in their browser wallet.
+//
+// For autosign (no browser), use pnl_claim_now.
+export const claimInputSchema = {
+    marketId: z
+        .string()
+        .min(1)
+        .describe("Market id from pnl_browse_markets or your wallet's history. Accepts the Mongo id or the on-chain market address. The market must be resolved (YES wins, NO wins, or refund) and the wallet must have an unclaimed position."),
+};
+const ClaimInput = z.object(claimInputSchema);
+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 callClaim(rawInput) {
+    const { marketId } = ClaimInput.parse(rawInput ?? {});
+    const base = getApiBase();
+    // Quick sanity fetch — surface the resolution + token mint info in
+    // the reply so the user knows what they're about to claim.
+    let market;
+    try {
+        market = await getMarket(marketId);
+    }
+    catch (e) {
+        return reply(headline(`${Badge.err} Couldn't load market \`${marketId}\``), `Check the id with \`pnl_browse_markets\`. Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const url = `${base}/market/${encodeURIComponent(marketId)}?claim=1`;
+    const resLabel = market.resolution || market.status || 'unknown';
+    return reply(headline(`${Badge.draft} Claim ready — ${market.name ?? marketId}`), `Open this URL to confirm and sign in your browser wallet:`, code(url), kvTable([
+        ['Market', market.name ?? marketId],
+        ['Resolution', resLabel],
+        ['Phase', market.phase ?? '—'],
+    ]), `The market detail page detects \`?claim=1\` and opens the claim panel. Sign the \`claim_rewards\` tx in your wallet — confirms in ~5-15s.`, next('Open the URL in a browser to sign.'));
+}

package/dist/tools/export-keypair.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const exportKeypairInputSchema: {
+    readonly confirm: z.ZodLiteral<"EXPORT">;
+};
+export declare function callExportKeypair(rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/export-keypair.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { hasWallet, isUnlocked, exportToFile } from '../lib/wallet.js';
+import { Badge, headline, code, inline, next, reply, quote, truncAddress } from '../lib/output.js';
+export const exportKeypairInputSchema = {
+    confirm: z
+        .literal('EXPORT')
+        .describe('Must be the literal string "EXPORT". Deliberate friction step — the user has to explicitly ask before the agent will dump the secret.'),
+};
+const ExportKeypairInput = z.object(exportKeypairInputSchema);
+export async function callExportKeypair(rawInput) {
+    ExportKeypairInput.parse(rawInput ?? {});
+    if (!hasWallet()) {
+        return reply(headline(`${Badge.warn} No PNL wallet to export.`), `Run ${inline('/pnl-init')} first.`);
+    }
+    if (!isUnlocked()) {
+        return reply(headline(`${Badge.locked} Wallet is locked.`), `Export needs the secret in memory. Run \`/pnl-unlock\` first — passphrase comes from \`PNL_PASSPHRASE\` env or OS-native dialog.`, next('`/pnl-unlock`, then `/pnl-export`.'));
+    }
+    try {
+        const { path, address } = exportToFile();
+        return reply(headline(`${Badge.ok} Exported · ${truncAddress(address)}`), `**File:**`, code(path), 'Open the file, copy the contents into your password manager (it has both base58 for Phantom-import and the Solana CLI JSON array), then delete:', code(`rm '${path}'`, 'bash'), quote('Anyone who reads this file can spend all SOL on the wallet. The file is mode 0600 (only your user can read it on this machine), but cloud-backup tools that sync ~/.config would expose it. Delete after the secret is in your password manager.'), next('Save the secret, then `rm` the file.'));
+    }
+    catch (e) {
+        return reply(headline(`${Badge.err} Export failed.`), e instanceof Error ? e.message : String(e));
+    }
+}

package/dist/tools/get-market.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const getMarketInputSchema: {
+    readonly marketId: z.ZodString;
+};
+export declare function callGetMarket(rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/get-market.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { getMarket, marketUrl } from '../lib/pnl-api.js';
+import { Badge, headline, kvTable, quote, next, reply, truncAddress, code } from '../lib/output.js';
+export const getMarketInputSchema = {
+    marketId: z
+        .string()
+        .min(1)
+        .describe("The market id (from pnl_browse_markets) or the on-chain base58 market address. The /api/markets/<id> endpoint accepts either."),
+};
+const GetMarketInput = z.object(getMarketInputSchema);
+function fmtSol(lamports) {
+    if (lamports == null)
+        return null;
+    const sol = lamports / 1e9;
+    if (sol < 0.001)
+        return null;
+    return `${sol.toFixed(sol < 1 ? 3 : 2)} SOL`;
+}
+function statusBadge(status, displayStatus) {
+    const s = (displayStatus || status || '').toLowerCase();
+    if (s.includes('active'))
+        return Badge.live;
+    if (s.includes('yes'))
+        return 'YES won';
+    if (s.includes('no'))
+        return 'NO won';
+    if (s.includes('refund'))
+        return 'refunded';
+    if (s.includes('expired') || s.includes('awaiting'))
+        return Badge.pending;
+    return displayStatus || status || '—';
+}
+export async function callGetMarket(rawInput) {
+    const { marketId } = GetMarketInput.parse(rawInput ?? {});
+    const m = await getMarket(marketId);
+    const symbol = m.tokenSymbol ? `$${m.tokenSymbol}` : '';
+    const yesPct = m.yesPercentage != null ? `${Math.round(m.yesPercentage)}% YES` : '';
+    const status = statusBadge(m.status, m.displayStatus);
+    const headerBits = [m.name, symbol && `· ${symbol}`, status && `· ${status}`, yesPct && `· ${yesPct}`]
+        .filter(Boolean)
+        .join(' ');
+    const founder = m.founderDisplayName || m.founderUsername;
+    const yesPool = fmtSol(m.yesPool ?? m.totalYesStake);
+    const noPool = fmtSol(m.noPool ?? m.totalNoStake);
+    return reply(headline(headerBits), kvTable([
+        ['Founder', founder ?? null],
+        ['Category', [m.category, m.stage].filter(Boolean).join(' · ') || null],
+        ['Status', `${status}${m.phase ? ` (${m.phase})` : ''}`],
+        ['YES support', m.yesPercentage != null ? `${Math.round(m.yesPercentage)}%` : null],
+        ['Pools', yesPool || noPool ? `YES ${yesPool ?? '—'} · NO ${noPool ?? '—'}` : null],
+        ['Target pool', m.targetPool ? `${m.targetPool}${m.poolProgressPercentage != null ? ` (${Math.round(m.poolProgressPercentage)}% filled)` : ''}` : null],
+        ['Voters', m.totalParticipants != null ? String(m.totalParticipants) : null],
+        ['Time left', m.timeLeft ?? (m.expiryTime ? m.expiryTime : null)],
+        ['On-chain market', m.marketAddress ? `\`${truncAddress(m.marketAddress, 8, 6)}\`` : null],
+        ['Token mint', m.tokenMint ? `\`${truncAddress(m.tokenMint, 8, 6)}\`` : null],
+        ['Pump.fun token', m.pumpFunTokenAddress ? `\`${truncAddress(m.pumpFunTokenAddress, 8, 6)}\`` : null],
+    ]), m.description ? quote(m.description.trim()) : null, `**Open on PNL:** ${marketUrl(m.id)}`, m.marketAddress ? code(m.marketAddress) : null, next('`/pnl-vote` to stake YES/NO (coming in Phase B), or share the URL.'));
+}

package/dist/tools/help.d.ts

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

package/dist/tools/help.js

@@ -0,0 +1,54 @@
+import { hasWallet, unlockStatus } from '../lib/wallet.js';
+import { Badge, headline, table, heading, next, reply } from '../lib/output.js';
+// ─── pnl_help ────────────────────────────────────────────────────
+//
+// Discoverability tool. Lists every PNL command + the typical flow
+// a new user follows. Surfaces context-aware suggestions based on
+// current state (does the user have a wallet? is it unlocked?).
+export const helpInputSchema = {};
+export async function callHelp(_rawInput) {
+    const wallet = hasWallet();
+    const { unlocked } = wallet ? unlockStatus() : { unlocked: false };
+    let situation;
+    let nextHint;
+    if (!wallet) {
+        situation = 'No wallet on this machine yet.';
+        nextHint = '`/pnl-init` to create one (or `/pnl-restore` if you have a BIP39 phrase).';
+    }
+    else if (!unlocked) {
+        situation = `Wallet exists · ${Badge.locked}`;
+        nextHint = '`/pnl-unlock` to enable signing, or `/pnl-pitch` to draft an idea (no unlock needed).';
+    }
+    else {
+        situation = `Wallet exists · ${Badge.unlocked}`;
+        nextHint = '`/pnl-pitch` to post an idea, `/pnl-wallet` for balance, `/pnl-browse` to see what\'s live.';
+    }
+    return reply(headline('PNL on the terminal — command reference'), `**Now:** ${situation}`, heading('Wallet (local, encrypted, BIP39-recoverable)'), table(['Command', 'What it does'], [
+        ['`/pnl-init`', 'First-run: generate keypair + 12-word mnemonic, encrypt with passphrase'],
+        ['`/pnl-wallet`', 'Address, balance, lock status, autosign cap (no unlock needed)'],
+        ['`/pnl-unlock`', 'Decrypt secret in memory for 5m (default). Passphrase via OS dialog or env'],
+        ['`/pnl-lock`', 'Wipe cached secret immediately'],
+        ['`/pnl-restore`', 'Rebuild wallet on a new machine from a BIP39 mnemonic'],
+        ['`/pnl-export`', 'Write secret to a 0600 file for password-manager backup (never to chat)'],
+    ]), heading('Identity'), table(['Command', 'What it does'], [
+        ['`/pnl-name`', 'Claim or rename your PNL username (signature-auth, no Privy / no email)'],
+    ]), heading('Markets — deep-link mode (browser signs)'), table(['Command', 'What it does'], [
+        ['`/pnl-browse`', 'List live conviction markets — YES%, pool, votes, founder'],
+        ['`/pnl-pitch`', 'Draft a market from current conversation context, return deep-link to confirm'],
+        ['`/pnl-vote`', 'Stake YES or NO on an existing market (deep-link to confirm in wallet)'],
+    ]), heading('Markets — autosign mode (MCP signs locally, no browser)'), table(['Command', 'What it does'], [
+        ['`/pnl-pitch-now`', `Pitch + create the market in one shot (wallet must be ${Badge.unlocked}, cost within autosign cap)`],
+        ['`/pnl-vote-now`', `Stake YES or NO without leaving the terminal (wallet must be ${Badge.unlocked}, amount within autosign cap)`],
+        ['`/pnl-claim-now`', `Claim rewards on a resolved market (wallet must be ${Badge.unlocked}, no cap — claim is a withdrawal)`],
+    ]), `_Autosign cap defaults to 0.05 SOL (override per-call with \`autosignCapSol\` or update \`~/.config/pnl/config.json\`). Claim has no cap — it's a withdrawal of funds the program already owes you._`, heading('Claim (deep-link mode)'), table(['Command', 'What it does'], [
+        ['`/pnl-claim`', 'Open the claim panel on /market/<id> — sign in browser wallet'],
+    ]), heading('Activity'), table(['Command', 'What it does'], [
+        ['`/pnl-notify`', 'New notifications since last check (votes on your markets, resolutions, claim-ready). Includes profile URL.'],
+    ]), heading('Typical first run'), [
+        '1. `/pnl-init` — set up wallet, write down the 12-word phrase',
+        '2. Send ≥ 0.05 SOL to the deposit address from Phantom / Solflare / exchange',
+        '3. `/pnl-unlock` — passphrase via OS dialog (or set `PNL_PASSPHRASE` in mcp config)',
+        '4. `/pnl-name` — pick a username',
+        '5. `/pnl-pitch` — post your first idea',
+    ].join('\n'), next(nextHint));
+}

package/dist/tools/init.d.ts

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

package/dist/tools/init.js

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { createWallet, hasWallet, getAddress, getBalanceSol, loadConfig, unlockWith, isUsingHostedRpc, writeMnemonicToFile, WALLET_PATHS, } from '../lib/wallet.js';
+import { promptPassphrase } from '../lib/passphrase.js';
+import { PublicKey } from '@solana/web3.js';
+import { Badge, headline, kvTable, code, inline, next, reply, hr, heading, quote, } from '../lib/output.js';
+// ─── pnl_init ────────────────────────────────────────────────────
+//
+// First-run setup. BIP39 mnemonic + Ed25519 keypair at
+// m/44'/501'/0'/0' (Phantom-compatible). Secret encrypted with
+// scrypt + AES-256-GCM, stored at ~/.config/pnl/wallet.enc (0600).
+// Passphrase pulled from PNL_PASSPHRASE env or OS-native dialog;
+// the mnemonic is displayed once and never persisted.
+export const initInputSchema = {};
+const InitInput = z.object(initInputSchema);
+export async function callInit(rawInput) {
+    InitInput.parse(rawInput ?? {});
+    if (hasWallet()) {
+        const address = getAddress();
+        const config = loadConfig();
+        let balance = '(unknown)';
+        try {
+            balance = `${(await getBalanceSol(new PublicKey(address))).toFixed(4)} SOL`;
+        }
+        catch {
+            /* leave as unknown */
+        }
+        return reply(headline(`Wallet already initialized · ${balance}`), kvTable([
+            ['Address', `\`${address}\``],
+            ['Balance', balance],
+            ['Autosign cap', `${config.autosignCapSol} SOL`],
+            ['Wallet file', `\`${WALLET_PATHS.wallet}\``],
+        ]), `To use the wallet for signing, run ${inline('/pnl-unlock')} — passphrase comes from your ${inline('PNL_PASSPHRASE')} env or an OS-native dialog. Never typed in chat.`, next('`/pnl-wallet` for current state, `/pnl-pitch` to post an idea.'));
+    }
+    // Fresh setup. Two-prompt confirm to catch typos.
+    const passphrase = promptPassphrase({
+        title: 'PNL Wallet — Setup',
+        prompt: 'Choose a passphrase for your new PNL wallet. You\'ll enter it again to confirm.',
+        confirm: true,
+    });
+    const { address, mnemonic } = createWallet(passphrase);
+    unlockWith(passphrase, 30); // auto-unlock for the next 30min
+    // The 12-word recovery phrase is the keys to the wallet. We MUST NOT
+    // return it in the agent's reply — that text would flow through the
+    // LLM API + sit in Claude Code's session transcript on disk. Instead,
+    // write it to a 0600 file and tell the user the path so they can
+    // `cat` it locally + move it to their password manager + delete.
+    const { path: mnemonicPath } = writeMnemonicToFile(mnemonic, address);
+    let balanceLine = '';
+    try {
+        const sol = await getBalanceSol(new PublicKey(address));
+        balanceLine = `${sol.toFixed(4)} SOL`;
+    }
+    catch {
+        /* skip */
+    }
+    return reply(headline(`Wallet created ${Badge.ok}`), kvTable([
+        ['Deposit address', `\`${address}\``],
+        ['Phantom deep-link', `\`solana:${address}\``],
+        balanceLine ? ['Balance', balanceLine] : null,
+        ['Status', `${Badge.unlocked} 30m`],
+    ].filter((r) => Array.isArray(r))), hr, heading('Recovery phrase — written to disk, NOT shown here'), `The 12-word BIP39 recovery phrase was written to ${inline(mnemonicPath)} (mode 0600). Open the file locally to read it — it is NOT in this transcript by design, because anything in this reply flows through the LLM API + is logged by Claude Code.`, code(`cat "${mnemonicPath}"`), quote('This 12-word phrase is the ONLY way to recover your wallet if you lose this machine. After you have moved it to a password manager / paper backup, DELETE the file: `rm "' + mnemonicPath + '"`. Anyone with the phrase can spend the funds.'), hr, heading('Next'), [
+        `1. \`cat\` the recovery file above and move the 12 words to your password manager / paper backup.`,
+        `2. ${inline(`rm "${mnemonicPath}"`)} when you are done so the cleartext mnemonic is not sitting in \`~/.config/pnl/exports/\`.`,
+        `3. Fund the wallet by sending ≥ 0.05 SOL to the deposit address from any Solana wallet.`,
+        `4. The wallet is unlocked for 30 minutes. After that, run \`/pnl-unlock\` to sign more transactions.`,
+    ].join('\n'), isUsingHostedRpc()
+        ? `_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, `Files: ${inline(WALLET_PATHS.wallet)} (mode 0600) · ${inline(WALLET_PATHS.exports)} (mode 0700)`, next('`/pnl-wallet` to see the address again, `/pnl-pitch` once funded.'));
+}

package/dist/tools/notify.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export declare const notifyInputSchema: {
+    readonly limit: z.ZodOptional<z.ZodNumber>;
+    readonly all: z.ZodOptional<z.ZodBoolean>;
+    readonly unreadOnly: z.ZodOptional<z.ZodBoolean>;
+};
+export declare function callNotify(rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;

package/dist/tools/notify.js

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { hasWallet, getAddress } from '../lib/wallet.js';
+import { Badge, headline, table, inline, truncAddress, heading, next, reply, } from '../lib/output.js';
+// ─── pnl_notify ──────────────────────────────────────────────────
+//
+// Pull recent notifications for the local wallet from PNL's
+// /api/notifications endpoint and format them for the agent. Stateful
+// via ~/.config/pnl/last-seen.json: tracks the most recent notification
+// id this tool has surfaced so subsequent calls only show new ones
+// (with --all to override).
+//
+// The agent typically invokes this when the user says "what's new on
+// PNL", "any updates on my market", or via /pnl-notify. Works without
+// any always-on process — pure on-demand poll.
+const LAST_SEEN_FILE = join(homedir(), '.config', 'pnl', 'last-seen.json');
+function loadLastSeen() {
+    try {
+        if (!existsSync(LAST_SEEN_FILE))
+            return { perWallet: {} };
+        const raw = readFileSync(LAST_SEEN_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && parsed.perWallet)
+            return parsed;
+        return { perWallet: {} };
+    }
+    catch {
+        return { perWallet: {} };
+    }
+}
+function saveLastSeen(state) {
+    const dir = join(homedir(), '.config', 'pnl');
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(LAST_SEEN_FILE, JSON.stringify(state, null, 2));
+}
+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 const notifyInputSchema = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .optional()
+        .describe('Max notifications to return per call. Default 10.'),
+    all: z
+        .boolean()
+        .optional()
+        .describe('When true, show ALL notifications regardless of last-seen state (useful for "show me the full activity feed"). When false (default), only return notifications newer than the last time pnl_notify was called.'),
+    unreadOnly: z
+        .boolean()
+        .optional()
+        .describe('Only return unread notifications. Default true.'),
+};
+const NotifyInput = z.object(notifyInputSchema);
+const TYPE_BADGE = {
+    vote_result: '[vote]',
+    token_launched: '[live]',
+    vote_reminder: '[!]',
+    reward_earned: '[ok]',
+    project_update: '[update]',
+    weekly_digest: '[digest]',
+    community_milestone: '[milestone]',
+    market_resolved: '[resolved]',
+    claim_ready: '[claim]',
+    pool_complete: '[pool]',
+    founder_voice_live: '[live]',
+};
+export async function callNotify(rawInput) {
+    const input = NotifyInput.parse(rawInput ?? {});
+    const limit = input.limit ?? 10;
+    const unreadOnly = input.unreadOnly ?? true;
+    const showAll = input.all ?? false;
+    if (!hasWallet()) {
+        return reply(headline('No wallet on this machine yet.'), `Run ${inline('pnl_init')} to set one up. Notifications are scoped to a wallet address — without one there's nothing to fetch.`);
+    }
+    const address = getAddress();
+    const base = getApiBase();
+    const qs = new URLSearchParams({ wallet: address, limit: String(Math.min(limit * 2, 50)) });
+    if (unreadOnly)
+        qs.set('unread', 'true');
+    let payload;
+    try {
+        const res = await fetch(`${base}/api/notifications?${qs.toString()}`, {
+            headers: {
+                Accept: 'application/json',
+                'User-Agent': 'pnl-mcp-server/0.3.0 (+https://docs.pnl.market)',
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`/api/notifications returned ${res.status} ${res.statusText}`);
+        }
+        payload = (await res.json());
+    }
+    catch (e) {
+        return reply(headline(`${Badge.err} Couldn't fetch notifications`), `Error: ${e instanceof Error ? e.message : String(e)}`, `Profile: ${base}/profile/${address}`);
+    }
+    const all = payload.notifications ?? [];
+    const state = loadLastSeen();
+    const lastSeenAt = state.perWallet[address];
+    const filtered = showAll
+        ? all
+        : lastSeenAt
+            ? all.filter((n) => (n.createdAt ?? '') > lastSeenAt)
+            : all;
+    const toShow = filtered.slice(0, limit);
+    // Bump last-seen to the newest createdAt in the API response (not
+    // just toShow) so we don't re-surface notifications we deliberately
+    // truncated with `limit`.
+    if (all.length > 0) {
+        const newest = all
+            .map((n) => n.createdAt ?? '')
+            .filter(Boolean)
+            .sort()
+            .pop();
+        if (newest) {
+            state.perWallet[address] = newest;
+            saveLastSeen(state);
+        }
+    }
+    const profileUrl = `${base}/profile/${address}`;
+    const profileLink = `[your profile](${profileUrl})`;
+    if (toShow.length === 0) {
+        if (showAll) {
+            return reply(headline(`${Badge.ok} No notifications`), `Your inbox for \`${truncAddress(address)}\` is empty.`, `${profileLink} · ${inline(profileUrl)}`, next('Stake on a market with `/pnl-vote` to start seeing activity here.'));
+        }
+        return reply(headline(`${Badge.ok} Nothing new since last check`), `Total unread: ${payload.unreadCount ?? 0}. Pass \`all: true\` to see the full inbox or visit ${profileLink}.`);
+    }
+    const rows = toShow.map((n) => {
+        const badge = TYPE_BADGE[n.type ?? ''] ?? '[ping]';
+        const when = n.createdAt ? new Date(n.createdAt).toISOString().slice(0, 16).replace('T', ' ') : '—';
+        const title = (n.title ?? '(no title)').slice(0, 70);
+        const ctx = n.marketId && typeof n.marketId === 'object' && n.marketId.marketName
+            ? `\`${n.marketId.marketName.slice(0, 30)}\``
+            : n.projectId && typeof n.projectId === 'object' && n.projectId.tokenSymbol
+                ? `\`$${n.projectId.tokenSymbol}\``
+                : '—';
+        return [badge, when, title, ctx];
+    });
+    return reply(headline(`${Badge.live} ${toShow.length} ${toShow.length === 1 ? 'update' : 'updates'} · ${truncAddress(address)}`), `${payload.unreadCount ?? 0} unread total · viewing ${showAll ? 'all' : 'new since last check'}.`, table(['Type', 'When (UTC)', 'Title', 'Market / Token'], rows), heading('Open in browser'), `${profileLink}: ${inline(profileUrl)}`, next(showAll
+        ? 'Mark items read in the browser — or stake / claim from here with `/pnl-vote-now` / `/pnl-claim-now`.'
+        : `Re-run with ${inline('all: true')} to see everything, or open ${profileLink} to mark items read.`));
+}

package/dist/tools/pitch-idea.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const pitchIdeaInputSchema: {
+    readonly name: z.ZodString;
+    readonly description: z.ZodString;
+    readonly tokenSymbol: z.ZodString;
+    readonly category: z.ZodEnum<["DeFi", "NFT", "Gaming", "DAO", "AI/ML", "Infrastructure", "Social", "Meme", "Creator", "Healthcare", "Science", "Education", "Finance", "Commerce", "Real Estate", "Energy", "Media", "Manufacturing", "Mobility", "Other"]>;
+    readonly projectType: z.ZodEnum<["Protocol", "Application", "Platform", "Service", "Tool"]>;
+    readonly projectStage: z.ZodEnum<["Idea", "MVP", "Beta", "Production", "Scaling", "Prototype", "Launched"]>;
+    readonly teamSize: z.ZodNumber;
+    readonly targetPoolSol: z.ZodNumber;
+    readonly durationDays: z.ZodNumber;
+    readonly projectImageUrl: z.ZodOptional<z.ZodString>;
+    readonly pitchVideoUrl: z.ZodOptional<z.ZodString>;
+    readonly twitterHandle: z.ZodOptional<z.ZodString>;
+    readonly location: z.ZodOptional<z.ZodString>;
+    readonly provenance: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<["claude-code", "cursor", "cline", "codex", "other"]>;
+        excerpt: z.ZodString;
+        codeSnippet: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: "claude-code" | "cursor" | "cline" | "codex" | "other";
+        excerpt: string;
+        codeSnippet?: string | undefined;
+        timestamp?: string | undefined;
+    }, {
+        source: "claude-code" | "cursor" | "cline" | "codex" | "other";
+        excerpt: string;
+        codeSnippet?: string | undefined;
+        timestamp?: string | undefined;
+    }>>;
+};
+export declare function callPitchIdea(rawInput: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;