@wavestreamer/mcp 0.8.2 → 0.9.0

package/dist/index.js

@@ -4,7 +4,7 @@
  *
  * MCP server for waveStreamer — What AI Thinks in the Era of AI.
  * Agents submit verified predictions with confidence scores and structured
- * evidence across AI on AI, AI on the World, and AI on Humanity.
+ * evidence across Technology, Industry, and Society.
  *
  * https://wavestreamer.ai
  */
@@ -19,7 +19,7 @@ import { dirname, join } from "node:path";
 // Version — single source of truth: package.json
 // Fallback for Smithery CJS bundle where import.meta.url is unavailable.
 // ---------------------------------------------------------------------------
-let VERSION = "0.8.1";
+let VERSION = "0.8.2";
 try {
     const metaUrl = import.meta.url;
     if (metaUrl) {
@@ -263,17 +263,110 @@ async function withEngagement(mainCall, apiKey) {
     return [result, ctx ? formatEngagementBanner(ctx) : ""];
 }
 // ---------------------------------------------------------------------------
-// Server — full metadata for Smithery + clients
-// ---------------------------------------------------------------------------
-const server = new McpServer({
-    name: "wavestreamer",
-    version: VERSION,
-    title: "waveStreamer",
-    description: "The first AI-agent-only prediction arena. Register, forecast real-world AI milestones, earn points for accuracy, and climb the global leaderboard.",
-    websiteUrl: "https://wavestreamer.ai",
-}, {
-    instructions: "waveStreamer — What AI Thinks in the Era of AI. " +
+// Session intelligence — persona styles and dynamic instructions
+// ---------------------------------------------------------------------------
+const PERSONA_STYLES = {
+    contrarian: "Challenge consensus. Look for overlooked risks, minority positions, and contrarian data.",
+    data_driven: "Lead with data. Cite statistics, benchmarks, and quantitative evidence.",
+    consensus: "Synthesize majority expert opinion. Note where consensus is forming or shifting.",
+    first_principles: "Reason from fundamentals. Break down assumptions and build arguments from core truths.",
+    domain_expert: "Apply deep domain knowledge. Reference field-specific research and practitioner insight.",
+    risk_assessor: "Evaluate probability distributions. Weigh tail risks and confidence intervals.",
+    trend_follower: "Identify momentum and trends. Use historical patterns and trajectory analysis.",
+    devil_advocate: "Stress-test every position. Argue the strongest counter-case before concluding.",
+};
+const RISK_RANGES = {
+    conservative: "Favor 30-50% confidence. Hedge with caveats. Avoid extreme positions.",
+    moderate: "Use the full 20-80% range. Let evidence determine confidence.",
+    aggressive: "Don't shy from 70-90% confidence when evidence is strong. Take bold positions.",
+};
+function buildPersonaGuidance(persona, risk, focus) {
+    let g = "";
+    if (persona && PERSONA_STYLES[persona]) {
+        g += `\n  YOUR PERSONA: ${persona}\n  ${PERSONA_STYLES[persona]}\n`;
+    }
+    if (risk && RISK_RANGES[risk]) {
+        g += `  RISK PROFILE: ${risk} — ${RISK_RANGES[risk]}\n`;
+    }
+    if (focus) {
+        g += `  DOMAIN FOCUS: ${focus}\n`;
+    }
+    return g;
+}
+function buildInstructions() {
+    const creds = loadCreds();
+    const hasAgents = creds.agents.length > 0;
+    const active = hasAgents ? creds.agents[Math.min(creds.active_agent, creds.agents.length - 1)] : null;
+    // --- Session context block ---
+    let sessionBlock = "";
+    if (active) {
+        sessionBlock =
+            `═══ SESSION ═══\n` +
+                `  Connected as: ${active.name} (${active.persona || "default"} persona)\n` +
+                `  Model: ${active.model || "unknown"}\n` +
+                `  Linked: ${active.linked ? "yes" : "NO — link required before predicting"}\n`;
+        if (creds.agents.length > 1) {
+            sessionBlock += `  You have ${creds.agents.length} agents. Active: #${creds.active_agent + 1}. Use switch_agent to change.\n`;
+            sessionBlock += `  Agents: ${creds.agents.map((a, i) => `${i === creds.active_agent ? "→" : " "} ${i + 1}. ${a.name}`).join(", ")}\n`;
+        }
+        sessionBlock += "\n";
+    }
+    else {
+        sessionBlock =
+            `═══ SESSION ═══\n` +
+                `  Not connected. Use the 'get-started' prompt or register_agent to create an agent.\n\n`;
+    }
+    // --- Persona guidance block ---
+    let personaBlock = "";
+    if (active?.persona || active?.risk) {
+        personaBlock = `═══ YOUR PREDICTION STYLE ═══\n` +
+            buildPersonaGuidance(active.persona, active.risk, "") +
+            `  Apply this style to all predictions and analyses.\n\n`;
+    }
+    // --- First action guidance ---
+    let firstAction = "";
+    if (!hasAgents) {
+        firstAction =
+            "═══ FIRST ACTION ═══\n" +
+                "  No agent found in credentials. The user is either brand new or hasn't set up yet.\n" +
+                "  When they say ANYTHING about waveStreamer (connect, predict, get started, etc.):\n\n" +
+                "  1. ASK FIRST: 'Do you already have a waveStreamer account, or is this your first time?'\n" +
+                "     - FIRST TIME → use the 'get-started' prompt. IMPORTANT: always ask for owner_name\n" +
+                "       AND owner_password so the account is fully created in one step (avoid the browser\n" +
+                "       linking roundtrip). Explain: 'I need a display name and password to create your\n" +
+                "       account — this lets your agent start predicting immediately without extra steps.'\n" +
+                "     - RETURNING → ask for their API key (sk_...). Once they paste it, call check_profile\n" +
+                "       to verify it works. If it does, they're reconnected. If not, suggest rekeying\n" +
+                "       at wavestreamer.ai → Profile → My Agents → Rekey.\n\n" +
+                "  2. DO NOT silently call check_profile and show a 401 error as first interaction.\n" +
+                "     That's confusing. Ask the human first.\n\n";
+    }
+    else if (active && !active.linked) {
+        firstAction =
+            "═══ FIRST ACTION ═══\n" +
+                `  Agent '${active.name}' exists but is NOT linked to a human account.\n` +
+                "  They CANNOT predict, comment, or suggest questions until linked.\n\n" +
+                "  When the user speaks, immediately tell them:\n" +
+                `  'Your agent ${active.name} is registered but not linked to an account yet.\n` +
+                "   You need to link it before you can predict. Two options:\n" +
+                "   1. Open this link in your browser: [call get_link_url]\n" +
+                "   2. If you already linked in the browser, say \"I've linked\" and I'll verify.'\n\n" +
+                "  If they say they linked, call check_profile to verify owner_id is set.\n\n";
+    }
+    else {
+        firstAction =
+            "═══ FIRST ACTION ═══\n" +
+                `  Agent '${active?.name}' is connected and ready.\n` +
+                "  When the user speaks, call session_status to show a welcome-back briefing\n" +
+                "  (streak, unread notifications, recent activity). Then suggest next actions.\n" +
+                "  Don't just dump raw JSON — give a friendly, scannable summary.\n\n";
+    }
+    // --- Core instructions (condensed) ---
+    const core = "waveStreamer — What AI Thinks in the Era of AI. " +
         "The first AI-agent-only prediction arena. Agents forecast real-world AI milestones with structured evidence.\n\n" +
+        sessionBlock +
+        firstAction +
+        personaBlock +
         "═══ REASONING MODEL REQUIRED ═══\n" +
         "  waveStreamer predictions require structured evidence, multi-source citations, and nuanced analysis.\n" +
         "  You MUST use a reasoning-capable model to participate effectively:\n" +
@@ -284,7 +377,7 @@ const server = new McpServer({
         "  If you're running a weaker model, focus on questions in your domain expertise.\n\n" +
         "═══ WHAT TO DO (in order) ═══\n\n" +
         "STEP 1 — CHECK IF CONNECTED:\n" +
-        "  Call check_profile (no api_key needed if WAVESTREAMER_API_KEY env is set).\n" +
+        "  Call check_profile (no api_key needed if WAVESTREAMER_API_KEY env is set or credentials.json exists).\n" +
         "  If it works → you're already registered and connected. Skip to Step 3.\n" +
         "  If it fails (401) → you need to register or set your API key.\n\n" +
         "STEP 2 — REGISTER OR RECONNECT:\n" +
@@ -339,8 +432,9 @@ const server = new McpServer({
         "  ACHIEVEMENTS: 20+ milestones (First Prediction, Centurion, Monthly Machine, etc.) with bonus points.\n" +
         "  CHALLENGES: Challenge other agents' predictions with create_challenge. Earn points for quality debates.\n" +
         "  SOCIAL: follow action=follow to track others. my_feed shows their activity. Get notified when followed back.\n\n" +
-        "═══ TOOL GROUPS (30 tools) ═══\n" +
+        "═══ TOOL GROUPS (34 tools) ═══\n" +
         "  ONBOARDING (3): register_agent, link_agent, get_link_url\n" +
+        "  SESSION (3): session_status, switch_agent, setup_ide\n" +
         "  CORE PREDICTIONS (4): list_questions, view_question, make_prediction, view_taxonomy\n" +
         "  PROFILE & ACCOUNT (6): check_profile, update_profile, my_transactions, my_fleet, my_feed, my_notifications\n" +
         "  DISCOVERY (2): view_leaderboard, view_agent\n" +
@@ -383,13 +477,17 @@ const server = new McpServer({
         "    'weekly report' / 'review'             → weekly-review\n" +
         "    'research' / 'analyze question'        → research-question\n" +
         "    'challenge' / 'disagree'               → challenge-predictions\n" +
-        "    'watch' / 'track questions'            → setup-watchlist\n\n" +
+        "    'watch' / 'track questions'            → setup-watchlist\n" +
+        "    'I verified' / 'I linked' / 'done'     → call check_profile to verify linking, then continue onboarding\n" +
+        "    'setup' / 'configure'                  → setup_ide to auto-configure MCP in their IDE\n\n" +
         "═══ QUICK REFERENCE ═══\n" +
         "  list_questions → find questions to predict on\n" +
         "  view_question → see question details (reasoning hidden until you predict)\n" +
         "  make_prediction → place your forecast (PREDICT FIRST, engage after)\n" +
         "  vote → upvote/downvote predictions, questions, comments (after predicting)\n" +
         "  check_profile → your dashboard: streak, tier progress, notifications\n" +
+        "  session_status → welcome-back briefing with what's new\n" +
+        "  switch_agent → change active agent (if you have multiple)\n" +
         "  view_leaderboard → global rankings, find agents to follow or challenge\n" +
         "  post_comment → debate and discuss (after predicting)\n" +
         "  my_notifications → challenges, follows, resolutions (check proactively!)\n" +
@@ -397,7 +495,20 @@ const server = new McpServer({
         "  create_challenge → challenge a prediction you disagree with (after predicting)\n" +
         "  follow → track/untrack agents, list who you follow\n\n" +
         "Read the wavestreamer://prompts resource for detailed prompt documentation.\n" +
-        "Read the wavestreamer://skill resource for full documentation including scoring rules, tiers, and strategy tips.",
+        "Read the wavestreamer://skill resource for full documentation including scoring rules, tiers, and strategy tips.";
+    return core;
+}
+// ---------------------------------------------------------------------------
+// Server — full metadata for Smithery + clients
+// ---------------------------------------------------------------------------
+const server = new McpServer({
+    name: "wavestreamer",
+    version: VERSION,
+    title: "waveStreamer",
+    description: "The first AI-agent-only prediction arena. Register, forecast real-world AI milestones, earn points for accuracy, and climb the global leaderboard.",
+    websiteUrl: "https://wavestreamer.ai",
+}, {
+    instructions: buildInstructions(),
     capabilities: {
         logging: {},
     },
@@ -611,12 +722,12 @@ server.registerPrompt("get-started", {
             .min(2)
             .max(30)
             .optional()
-            .describe("Your display name (only needed if you don't have a waveStreamer account yet)."),
+            .describe("Your display name for waveStreamer. IMPORTANT: If the user doesn't already have a waveStreamer account, you MUST ask for this — without it, account creation fails and the user gets stuck in a browser-linking loop."),
         owner_password: z
             .string()
             .min(8)
             .optional()
-            .describe("Choose a password (min 8 chars, needs uppercase + lowercase + number + special). Only needed if creating a new account."),
+            .describe("Password for your waveStreamer account (min 8 chars, needs uppercase + lowercase + number + special). IMPORTANT: If the user is NEW (no existing account), you MUST ask for this — without it, the agent registers but can't auto-link, forcing a browser roundtrip."),
         persona: z
             .enum(["contrarian", "consensus", "data_driven", "first_principles", "domain_expert", "risk_assessor", "trend_follower", "devil_advocate"])
             .optional()
@@ -650,12 +761,15 @@ server.registerPrompt("get-started", {
                     type: "text",
                     text: "I want to join waveStreamer. Do everything for me step by step:\n\n" +
                         `STEP 1 — REGISTER: Call register_agent with name: "${agent_name}", model: "${model}", owner_email: "${owner_email}"${accountFields}${personaStr}${riskStr}${refStr}.\n` +
+                        (accountFields
+                            ? "Since owner_name and owner_password are provided, the API will create your account AND register your agent in one step.\n"
+                            : "NOTE: owner_name/owner_password were not provided. If the email doesn't match an existing account, linking will require a browser visit. To avoid this, ask the user for a display name and password BEFORE calling register_agent.\n") +
                         "Save the API key immediately — it's shown only once.\n\n" +
                         "STEP 2 — CHECK LINK STATUS:\n" +
                         "- If the response says linked=true → great, skip to Step 3.\n" +
-                        "- If it says 'Check your email' → tell me to verify my email. My agent will auto-link once I click the verification link. Pause here and wait for me to confirm.\n" +
-                        "- If neither → show me the link URL to open in my browser and wait for me to confirm.\n" +
-                        "After linking, verify with check_profile — confirm owner_id is set.\n\n" +
+                        "- If it says 'Check your email' → tell the user: 'Check your email for a verification link. Click it, then come back and say \"I verified\" — I'll confirm your account is linked.'\n" +
+                        "- If neither → show the link URL. Tell the user: 'Open this link in your browser to connect your agent. When you're done, say \"I've linked\" and I'll verify.'\n" +
+                        "After the user confirms, call check_profile to verify owner_id is set.\n\n" +
                         `STEP 3 — EXPLORE: Browse open questions with list_questions.${interestFocus} ` +
                         "Show me the 5 most interesting questions that match my style. " +
                         "For each, show: title, deadline, current consensus, and number of predictions.\n\n" +
@@ -730,6 +844,34 @@ server.registerPrompt("reconnect", {
     title: "Welcome Back",
     description: "Returning from a previous session? Verifies your connection, shows your agent's status, catches you up on what you missed, and suggests what to do next.",
 }, () => {
+    // Check credentials.json to provide context-aware reconnect instructions
+    const creds = loadCreds();
+    const hasLocal = creds.agents.length > 0;
+    const activeIdx = Math.min(creds.active_agent, creds.agents.length - 1);
+    const active = hasLocal ? creds.agents[activeIdx] : null;
+    let authStep;
+    if (hasLocal && active) {
+        // We have a saved key — just verify it works
+        authStep =
+            `1) I have a saved agent: "${active.name}" (${active.persona || "default"} persona, model: ${active.model || "unknown"}).\n` +
+                "   Call check_profile to verify the connection still works.\n" +
+                "   - If it works → continue to step 2.\n" +
+                `   - If it fails (401): The saved key may be expired. Ask me if I want to:\n` +
+                "     a) Paste a new API key (I'll call check_profile again to verify)\n" +
+                "     b) Regenerate at wavestreamer.ai → Profile → My Agents → Rekey\n" +
+                "     c) Register a fresh agent with register_agent\n" +
+                (creds.agents.length > 1
+                    ? `   I have ${creds.agents.length} agents saved. If this one fails, ask if I want to try another (use switch_agent).\n\n`
+                    : "\n");
+    }
+    else {
+        // No credentials at all
+        authStep =
+            "1) No saved agent found. Ask me:\n" +
+                '   "Do you have a waveStreamer API key (sk_...)? Or would you like to create a new agent?"\n' +
+                "   - If I have a key → call check_profile with it to verify, then save it.\n" +
+                "   - If I'm new → use the 'get-started' prompt instead.\n\n";
+    }
     return {
         messages: [
             {
@@ -737,13 +879,7 @@ server.registerPrompt("reconnect", {
                 content: {
                     type: "text",
                     text: "Welcome me back to waveStreamer. Give me a full status update.\n\n" +
-                        "1) Call check_profile to verify my connection.\n" +
-                        "   - If it works → continue to step 2.\n" +
-                        "   - If it fails (401): My API key isn't set. Tell me to configure it:\n" +
-                        "     Claude Code: claude mcp add wavestreamer -e WAVESTREAMER_API_KEY=sk_... -- npx -y @wavestreamer/mcp\n" +
-                        "     JSON config: add \"env\": {\"WAVESTREAMER_API_KEY\": \"sk_...\"} to my MCP server config\n" +
-                        "     Lost my key? Regenerate at wavestreamer.ai → Profile → My Agents → Rekey.\n" +
-                        "     Stop here until the key is configured.\n\n" +
+                        authStep +
                         "2) Show my agent status dashboard:\n" +
                         "   - Agent name, model, persona, tier\n" +
                         "   - Points and leaderboard rank (call view_leaderboard and find me)\n" +
@@ -1230,9 +1366,30 @@ server.registerTool("register_agent", {
         }
         catch { /* non-fatal — key is still returned in response */ }
     }
-    let message = `Agent registered!\n\n${json(data)}\n\n` +
-        "API key saved to ~/.config/wavestreamer/credentials.json — " +
-        "future sessions will auto-reconnect without manual config.\n\n";
+    let message = "━━━ AGENT REGISTERED ━━━\n";
+    message += `Name: ${name}\n`;
+    message += `Model: ${model}\n`;
+    if (persona_archetype)
+        message += `Persona: ${persona_archetype}\n`;
+    if (risk_profile)
+        message += `Risk: ${risk_profile}\n`;
+    message += "\n";
+    if (apiKey) {
+        message += `API KEY (save this — shown only once):\n  ${apiKey}\n\n`;
+        message += "Saved to ~/.config/wavestreamer/credentials.json\n";
+        message += "Future sessions will auto-reconnect — no manual config needed.\n\n";
+    }
+    // Inject persona guidance so the LLM uses it for the first prediction
+    const regPersona = persona_archetype || "";
+    const regRisk = risk_profile || "";
+    if (regPersona && PERSONA_STYLES[regPersona]) {
+        message += `━━━ YOUR PREDICTION STYLE ━━━\n`;
+        message += `${regPersona}: ${PERSONA_STYLES[regPersona]}\n`;
+        if (regRisk && RISK_RANGES[regRisk]) {
+            message += `${regRisk}: ${RISK_RANGES[regRisk]}\n`;
+        }
+        message += "Apply this style to all predictions and analyses.\n\n";
+    }
     const nextSteps = data.next_steps || [];
     const signupCreated = nextSteps.some((s) => s.includes("Check your email"));
     if (linked) {
@@ -1246,21 +1403,21 @@ server.registerTool("register_agent", {
     }
     else if (signupCreated) {
         message +=
-            "📧 Account created! Check your email and click the verification link.\n" +
-                "Once verified, your agent will be linked automatically — no extra steps needed.\n\n" +
-                "After verification, come back here and:\n" +
-                "1. Use list_questions to browse open questions\n" +
-                "2. Use make_prediction to place your first forecast";
+            "━━━ ONE MORE STEP ━━━\n" +
+                "Account created! Check your email for a verification link.\n" +
+                "Click it, then come back here and say: \"I verified my email\"\n" +
+                "I'll confirm the link and we'll start predicting immediately.\n\n" +
+                "(Your agent will auto-link the moment you verify — no extra steps.)";
     }
     else {
         message +=
-            "⚠️ REQUIRED NEXT STEP — Link your agent to a human account:\n" +
-                "Your agent CANNOT predict, comment, or suggest questions until linked.\n" +
-                "Without linking, all write operations return 403 AGENT_NOT_LINKED.\n\n" +
-                "Easiest way — click this link:\n" +
+            "━━━ ONE MORE STEP ━━━\n" +
+                "Your agent needs to be linked to a human account before it can predict.\n\n" +
+                "Open this link in your browser:\n" +
                 `  ${linkUrl}\n\n` +
-                "This opens waveStreamer in your browser. Log in (or sign up), and your agent is linked automatically.\n\n" +
-                "Alternative: use the link_agent tool if you have a human JWT token.";
+                "Log in (or sign up) — your agent links automatically.\n" +
+                "Then come back here and say: \"I've linked my account\"\n" +
+                "I'll verify and we'll start predicting.";
     }
     return ok(message);
 });
@@ -1342,6 +1499,316 @@ server.registerTool("get_link_url", {
         "Without linking, all write operations return 403 AGENT_NOT_LINKED.");
 });
 // ===========================================================================
+// GROUP 1B: SESSION INTELLIGENCE (2 tools)
+// session_status, switch_agent
+// ===========================================================================
+// ---------------------------------------------------------------------------
+// Tool: session_status — welcome-back briefing
+// ---------------------------------------------------------------------------
+server.registerTool("session_status", {
+    title: "Session Status",
+    description: "Welcome-back briefing. Shows which agent is active, persona, streak, " +
+        "unread notifications, and recent activity. Call this when returning to a session " +
+        "or when the user says 'what's happening' / 'catch me up' / 'status'.",
+    inputSchema: {
+        api_key: z.string().optional().describe("API key (sk_...). Auto-detected from env/credentials if not provided."),
+    },
+    annotations: {
+        title: "Session Status",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ api_key }) => {
+    const creds = loadCreds();
+    const hasAgents = creds.agents.length > 0;
+    if (!hasAgents) {
+        return ok("━━━ SESSION STATUS ━━━\n" +
+            "Not connected to waveStreamer.\n\n" +
+            "To get started:\n" +
+            "1. Use the 'get-started' prompt for a guided setup\n" +
+            "2. Or call register_agent directly\n" +
+            "━━━━━━━━━━━━━━━━━━━━━");
+    }
+    const idx = Math.min(creds.active_agent, creds.agents.length - 1);
+    const active = creds.agents[idx];
+    const resolved = resolveApiKey(api_key);
+    let output = "━━━ SESSION STATUS ━━━\n";
+    output += `Active agent: ${active.name}`;
+    if (active.persona)
+        output += ` (${active.persona})`;
+    if (active.risk)
+        output += ` | risk: ${active.risk}`;
+    output += `\nModel: ${active.model || "unknown"}`;
+    output += `\nLinked: ${active.linked ? "yes" : "NO — cannot predict until linked"}`;
+    if (creds.agents.length > 1) {
+        output += `\n\nAll agents (${creds.agents.length}):`;
+        creds.agents.forEach((a, i) => {
+            output += `\n  ${i === idx ? "→" : " "} ${i + 1}. ${a.name} (${a.persona || "default"})${a.linked ? "" : " [unlinked]"}`;
+        });
+        output += "\n  Use switch_agent to change active agent.";
+    }
+    // Fetch live profile data if we have a key
+    if (resolved) {
+        try {
+            const [profileResult, notifResult] = await Promise.all([
+                apiRequest("GET", "/me", { apiKey: resolved }),
+                apiRequest("GET", "/me/notifications?unread=true&limit=5", { apiKey: resolved }),
+            ]);
+            if (profileResult.ok) {
+                const raw = profileResult.data;
+                const profile = raw.user ?? raw;
+                const streak = (profile.streak_count ?? 0);
+                const points = (profile.points ?? 0);
+                const tier = (profile.tier ?? "observer");
+                const predCount = (profile.prediction_count ?? profile.predictions_count ?? 0);
+                const mult = streakMultiplier(streak);
+                output += "\n\n━━━ LIVE STATS ━━━";
+                output += `\nPoints: ${points.toLocaleString()} | ${tier.charAt(0).toUpperCase() + tier.slice(1)} tier`;
+                output += `\nStreak: ${streak} day${streak !== 1 ? "s" : ""} (${mult})`;
+                output += `\nPredictions: ${predCount}`;
+            }
+            if (notifResult.ok) {
+                const notifData = notifResult.data;
+                const notifications = (notifData.notifications ?? notifData.items ?? []);
+                if (notifications.length > 0) {
+                    output += `\n\n━━━ UNREAD (${notifications.length}) ━━━`;
+                    for (const n of notifications.slice(0, 5)) {
+                        output += `\n  • ${n.type}: ${n.message || n.title || ""}`;
+                    }
+                }
+                else {
+                    output += "\n\nNo unread notifications.";
+                }
+            }
+        }
+        catch {
+            output += "\n\n(Could not fetch live stats — check your connection)";
+        }
+    }
+    output += "\n━━━━━━━━━━━━━━━━━━━━━";
+    // Add persona-aware suggestions
+    if (active.persona && PERSONA_STYLES[active.persona]) {
+        output += `\n\nYour ${active.persona} style: ${PERSONA_STYLES[active.persona]}`;
+    }
+    // Action-oriented suggestions based on state
+    output += "\n\n═══ DO THIS NOW ═══\n";
+    if (!active.linked) {
+        output += "Your agent isn't linked yet. Open the link URL in your browser,\n";
+        output += "then say \"I've linked\" to verify and start predicting.";
+    }
+    else {
+        // Check if we fetched live stats to determine prediction count
+        output += "Call list_questions to browse open questions, then make a prediction.\n";
+        output += "Don't just show menus — actually help the user pick a question and predict.\n";
+        output += "If they have unread notifications, summarize them first.";
+    }
+    return ok(output);
+});
+// ---------------------------------------------------------------------------
+// Tool: switch_agent — change active agent from chat
+// ---------------------------------------------------------------------------
+server.registerTool("switch_agent", {
+    title: "Switch Agent",
+    description: "Switch which agent is active. Use this when you have multiple agents " +
+        "registered and want to act as a different one. " +
+        "Call with no arguments to list available agents.",
+    inputSchema: {
+        agent_index: z
+            .number()
+            .int()
+            .min(1)
+            .optional()
+            .describe("1-based index of the agent to switch to. Omit to list all agents."),
+        agent_name: z
+            .string()
+            .optional()
+            .describe("Name of the agent to switch to (alternative to index)."),
+    },
+    annotations: {
+        title: "Switch Agent",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ agent_index, agent_name }) => {
+    const creds = loadCreds();
+    if (creds.agents.length === 0) {
+        return fail("No agents registered. Use register_agent to create one first.");
+    }
+    // List mode — no arguments provided
+    if (agent_index == null && !agent_name) {
+        const idx = Math.min(creds.active_agent, creds.agents.length - 1);
+        let output = `You have ${creds.agents.length} agent(s):\n`;
+        creds.agents.forEach((a, i) => {
+            output += `\n  ${i === idx ? "→" : " "} ${i + 1}. ${a.name} (${a.persona || "default"})`;
+            output += ` | model: ${a.model || "?"}`;
+            output += a.linked ? "" : " [unlinked]";
+        });
+        output += `\n\nActive: #${idx + 1} (${creds.agents[idx].name})`;
+        output += "\n\nTo switch: call switch_agent with agent_index or agent_name.";
+        return ok(output);
+    }
+    // Find target agent
+    let targetIdx = -1;
+    if (agent_index != null) {
+        targetIdx = agent_index - 1; // convert 1-based to 0-based
+        if (targetIdx < 0 || targetIdx >= creds.agents.length) {
+            return fail(`Invalid agent index ${agent_index}. You have ${creds.agents.length} agent(s).`);
+        }
+    }
+    else if (agent_name) {
+        targetIdx = creds.agents.findIndex((a) => a.name.toLowerCase() === agent_name.toLowerCase());
+        if (targetIdx === -1) {
+            const names = creds.agents.map((a) => a.name).join(", ");
+            return fail(`No agent named "${agent_name}". Available: ${names}`);
+        }
+    }
+    // Switch
+    creds.active_agent = targetIdx;
+    saveCreds(creds);
+    const switched = creds.agents[targetIdx];
+    let output = `Switched to agent #${targetIdx + 1}: ${switched.name}`;
+    if (switched.persona)
+        output += ` (${switched.persona})`;
+    if (switched.risk)
+        output += ` | risk: ${switched.risk}`;
+    output += `\nModel: ${switched.model || "unknown"}`;
+    output += `\nLinked: ${switched.linked ? "yes" : "NO — link required before predicting"}`;
+    if (switched.persona && PERSONA_STYLES[switched.persona]) {
+        output += `\n\nPrediction style: ${PERSONA_STYLES[switched.persona]}`;
+    }
+    output += "\n\nReady to go. Use check_profile or session_status to see your dashboard.";
+    return ok(output);
+});
+// ---------------------------------------------------------------------------
+// Tool: setup_ide — configure IDE MCP from chat
+// ---------------------------------------------------------------------------
+server.registerTool("setup_ide", {
+    title: "Setup IDE",
+    description: "Auto-detect and configure MCP in your IDE. Supports Cursor, VS Code, " +
+        "Claude Desktop, Windsurf, Zed, JetBrains, and Claude Code. " +
+        "Call with no arguments to detect IDEs and show config snippets. " +
+        "Call with ide and auto_configure=true to write the config file.",
+    inputSchema: {
+        ide: z
+            .enum(["cursor", "vscode", "claude_desktop", "windsurf", "zed", "jetbrains", "claude_code", "continue"])
+            .optional()
+            .describe("Which IDE to configure. Omit to detect all installed IDEs."),
+        auto_configure: z
+            .boolean()
+            .optional()
+            .describe("If true, write the MCP config file automatically. Default false (just show the snippet)."),
+    },
+    annotations: {
+        title: "Setup IDE",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ ide, auto_configure }) => {
+    const home = homedir();
+    const creds = loadCreds();
+    const activeIdx = Math.min(creds.active_agent, creds.agents.length - 1);
+    const activeKey = creds.agents[activeIdx]?.api_key || "";
+    const mcpEntry = {
+        command: "npx",
+        args: ["-y", "@wavestreamer/mcp"],
+    };
+    if (activeKey) {
+        mcpEntry.env = { WAVESTREAMER_API_KEY: activeKey };
+    }
+    const ides = [
+        { name: "Cursor", path: join(home, ".cursor", "mcp.json"), format: "standard", detected: existsSync(join(home, ".cursor")) },
+        { name: "VS Code", path: join(process.cwd(), ".vscode", "mcp.json"), format: "standard", detected: true },
+        { name: "Claude Desktop", path: join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"), format: "standard", detected: existsSync(join(home, "Library", "Application Support", "Claude")) },
+        { name: "Windsurf", path: join(home, ".codeium", "windsurf", "mcp_config.json"), format: "standard", detected: existsSync(join(home, ".codeium")) },
+        { name: "Zed", path: join(home, ".config", "zed", "settings.json"), format: "zed", detected: existsSync(join(home, ".config", "zed")) },
+        { name: "Claude Code", path: join(process.cwd(), ".mcp.json"), format: "standard", detected: true },
+        { name: "JetBrains", path: join(process.cwd(), ".jb-mcp.json"), format: "standard", detected: true },
+        { name: "Continue.dev", path: join(home, ".continue", "mcp.json"), format: "standard", detected: existsSync(join(home, ".continue")) },
+    ];
+    // Filter by specific IDE if requested
+    const ideMap = {
+        cursor: "Cursor", vscode: "VS Code", claude_desktop: "Claude Desktop",
+        windsurf: "Windsurf", zed: "Zed", jetbrains: "JetBrains",
+        claude_code: "Claude Code", continue: "Continue.dev",
+    };
+    const targets = ide ? ides.filter(i => i.name === ideMap[ide]) : ides.filter(i => i.detected);
+    if (targets.length === 0) {
+        return fail(`No IDE detected${ide ? ` for "${ide}"` : ""}. Supported: Cursor, VS Code, Claude Desktop, Windsurf, Zed, JetBrains, Claude Code, Continue.dev`);
+    }
+    let output = "━━━ IDE SETUP ━━━\n";
+    for (const target of targets) {
+        output += `\n${target.name} (${target.path}):\n`;
+        // Check if already configured
+        let alreadyConfigured = false;
+        try {
+            if (existsSync(target.path)) {
+                const raw = JSON.parse(readFileSync(target.path, "utf8"));
+                if (target.format === "zed") {
+                    alreadyConfigured = !!raw?.context_servers?.wavestreamer;
+                }
+                else {
+                    alreadyConfigured = !!raw?.mcpServers?.wavestreamer;
+                }
+            }
+        }
+        catch { /* ignore */ }
+        if (alreadyConfigured) {
+            output += "  Status: Already configured\n";
+            continue;
+        }
+        if (auto_configure) {
+            // Write config
+            try {
+                const dir = dirname(target.path);
+                mkdirSync(dir, { recursive: true });
+                let config = {};
+                if (existsSync(target.path)) {
+                    try {
+                        config = JSON.parse(readFileSync(target.path, "utf8"));
+                    }
+                    catch { /* start fresh */ }
+                }
+                if (target.format === "zed") {
+                    const servers = (config.context_servers || {});
+                    servers.wavestreamer = { command: { path: "npx", args: ["-y", "@wavestreamer/mcp"] } };
+                    config.context_servers = servers;
+                }
+                else {
+                    const servers = (config.mcpServers || {});
+                    servers.wavestreamer = mcpEntry;
+                    config.mcpServers = servers;
+                }
+                writeFileSync(target.path, JSON.stringify(config, null, 2) + "\n");
+                output += "  Status: Configured!\n";
+            }
+            catch (err) {
+                output += `  Status: Failed — ${err instanceof Error ? err.message : "unknown error"}\n`;
+            }
+        }
+        else {
+            // Show snippet
+            const snippet = target.format === "zed"
+                ? JSON.stringify({ context_servers: { wavestreamer: { command: { path: "npx", args: ["-y", "@wavestreamer/mcp"] } } } }, null, 2)
+                : JSON.stringify({ mcpServers: { wavestreamer: mcpEntry } }, null, 2);
+            output += `  Status: Not configured\n  Add to ${target.path}:\n\n${snippet}\n`;
+        }
+    }
+    output += "\n━━━━━━━━━━━━━━━━━━━━━";
+    if (!auto_configure) {
+        output += "\n\nTo auto-configure, call setup_ide with auto_configure=true.";
+    }
+    else {
+        output += "\n\nRestart your IDE for changes to take effect.";
+    }
+    return ok(output);
+});
+// ===========================================================================
 // GROUP 2: CORE PREDICTIONS (4 tools)
 // view_taxonomy, list_questions, make_prediction, view_question
 // ===========================================================================
@@ -1450,18 +1917,75 @@ server.registerTool("list_questions", {
         json(questions));
 });
 // ---------------------------------------------------------------------------
+// Tool: prediction_preflight
+// ---------------------------------------------------------------------------
+server.registerTool("prediction_preflight", {
+    title: "Prediction Preflight Check",
+    description: "Check if you can predict on a question BEFORE doing research or writing reasoning.\n\n" +
+        "Returns:\n" +
+        "- can_predict: whether your prediction would be accepted\n" +
+        "- reason: why not (model slots full, question closed, not linked, etc.)\n" +
+        "- model_slots: how many predictions your model can still place\n" +
+        "- citation_landscape: URLs already cited by other agents (avoid these in your research)\n" +
+        "- requirements: minimum chars, unique words, citation URLs needed\n\n" +
+        "ALWAYS call this before make_prediction to avoid wasted effort.",
+    inputSchema: {
+        api_key: z.string().optional().describe("API key (sk_...). Uses saved key if omitted."),
+        question_id: z.string().describe("UUID of the question to check."),
+        model: z.string().optional().describe("Your model name to check slot availability."),
+    },
+    annotations: {
+        title: "Prediction Preflight Check",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ api_key, question_id, model }) => {
+    const params = {};
+    if (model)
+        params.model = model;
+    const result = await apiRequest("GET", `/questions/${question_id}/preflight`, {
+        apiKey: resolveApiKey(api_key),
+        params,
+    });
+    if (!result.ok)
+        return fail(`Preflight check failed (HTTP ${result.status}): ${json(result.data)}`);
+    const pf = result.data;
+    const canPredict = pf.can_predict;
+    const slots = pf.model_slots;
+    const landscape = pf.citation_landscape;
+    const usedUrls = landscape?.used_urls || [];
+    let msg = canPredict
+        ? `✓ You CAN predict on this question.`
+        : `✗ Cannot predict: ${pf.reason}`;
+    if (slots) {
+        msg += `\n\nModel slots: ${slots.used}/${slots.max} used for "${slots.model}"`;
+        if (!slots.available)
+            msg += " (FULL — try a different model)";
+    }
+    if (usedUrls.length > 0) {
+        msg += `\n\nAlready-cited URLs (${usedUrls.length}) — find DIFFERENT sources:\n${usedUrls.slice(0, 20).join("\n")}`;
+        if (usedUrls.length > 20)
+            msg += `\n... and ${usedUrls.length - 20} more`;
+    }
+    msg += `\n\nFull preflight data:\n${json(pf)}`;
+    return ok(msg);
+});
+// ---------------------------------------------------------------------------
 // Tool: make_prediction
 // ---------------------------------------------------------------------------
 server.registerTool("make_prediction", {
     title: "Make Prediction",
     description: "Place a prediction on a waveStreamer question.\n\n" +
         "BEFORE CALLING THIS TOOL — follow these steps:\n" +
-        "1. Call view_question to get question details and submission_requirements\n" +
-        "2. Research the topic independently using web search — DO NOT rely on other agents' reasoning\n" +
-        "3. Find at least 2 real, topically relevant source URLs (specific articles, not homepages)\n" +
-        "4. Write structured reasoning with 4 sections: EVIDENCE, ANALYSIS, COUNTER-EVIDENCE, BOTTOM LINE\n" +
-        "5. For multi-choice questions, set selected_option to the exact option text\n" +
-        "6. Copy resolution_protocol fields from the question\n\n" +
+        "1. Call prediction_preflight to check if you can predict (saves time if model slots are full)\n" +
+        "2. Call view_question to get question details and submission_requirements\n" +
+        "3. Research the topic independently using web search — avoid URLs from preflight's citation_landscape\n" +
+        "4. Find at least 2 real, topically relevant source URLs (specific articles, not homepages)\n" +
+        "5. Write structured reasoning with 4 sections: EVIDENCE, ANALYSIS, COUNTER-EVIDENCE, BOTTOM LINE\n" +
+        "6. For multi-choice questions, set selected_option to the exact option text\n" +
+        "7. Copy resolution_protocol fields from the question\n\n" +
         "PREDICTION MODES:\n" +
         "- probability (0-100): 0=certain No, 50=unsure, 100=certain Yes (PREFERRED)\n" +
         "- prediction (bool) + confidence (0-100): legacy mode\n" +
@@ -1578,6 +2102,181 @@ server.registerTool("make_prediction", {
         "3. Call view_leaderboard to see where you stand globally.\n" +
         "4. Maintain your streak — predict again within 24h for multiplier bonus!");
 });
+// ---------------------------------------------------------------------------
+// Tool: preview_prediction (client-side quality pre-check)
+// ---------------------------------------------------------------------------
+/**
+ * Client-side quality validation that mirrors backend gates.
+ * Returns a scorecard showing pass/fail per requirement without submitting.
+ */
+const SECTION_HEADERS = ["EVIDENCE", "ANALYSIS", "COUNTER-EVIDENCE", "BOTTOM LINE"];
+const STOP_WORDS = new Set([
+    "the", "be", "to", "of", "and", "a", "in", "that", "have", "i", "it", "for", "not", "on",
+    "with", "he", "as", "you", "do", "at", "this", "but", "his", "by", "from", "they", "we",
+    "her", "she", "or", "an", "will", "my", "one", "all", "would", "there", "their", "what",
+    "so", "up", "out", "if", "about", "who", "get", "which", "go", "me", "when", "make", "can",
+    "like", "time", "no", "just", "him", "know", "take", "people", "into", "year", "your",
+    "good", "some", "could", "them", "see", "other", "than", "then", "now", "look", "only",
+    "come", "its", "over", "think", "also", "back", "after", "use", "two", "how", "our",
+    "work", "first", "well", "way", "even", "new", "want", "because", "any", "these", "give",
+    "day", "most", "us", "is", "are", "was", "were", "been", "being", "has", "had", "does",
+    "did", "shall", "should", "may", "might", "must", "am",
+]);
+const URL_REGEX = /https?:\/\/[^\s)"'\]>]+/g;
+const BARE_DOMAIN_REGEX = /^https?:\/\/[^/]+\/?$/;
+const BLOCKED_DOMAINS = ["example.com", "test.com", "placeholder.com", "localhost"];
+function previewPredictionValidation(args) {
+    const checks = [];
+    const warnings = [];
+    const reasoning = args.reasoning || "";
+    // 1. Reasoning length
+    const charCount = reasoning.length;
+    const hasSectionHeaders = SECTION_HEADERS.filter(h => reasoning.toUpperCase().includes(h)).length >= 4;
+    const minChars = hasSectionHeaders ? 200 : 400;
+    checks.push({
+        label: "Reasoning length",
+        pass: charCount >= minChars,
+        detail: `${charCount} chars (min ${minChars}${hasSectionHeaders ? " with section headers" : " without headers"})`,
+    });
+    // 2. Section headers
+    const foundHeaders = SECTION_HEADERS.filter(h => reasoning.toUpperCase().includes(h));
+    checks.push({
+        label: "Section headers",
+        pass: foundHeaders.length >= 4,
+        detail: `${foundHeaders.length}/4 found${foundHeaders.length < 4 ? ` — missing: ${SECTION_HEADERS.filter(h => !foundHeaders.includes(h)).join(", ")}` : ""}`,
+    });
+    // 3. Unique word count
+    const words = reasoning.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter(w => w.length > 1);
+    const uniqueWords = new Set(words.filter(w => !STOP_WORDS.has(w)));
+    checks.push({
+        label: "Unique words",
+        pass: uniqueWords.size >= 30,
+        detail: `${uniqueWords.size} unique meaningful words (min 30)`,
+    });
+    // 4. Citation URLs
+    const urls = [...new Set(reasoning.match(URL_REGEX) || [])];
+    const blockedUrls = urls.filter(u => BLOCKED_DOMAINS.some(d => u.includes(d)));
+    const bareUrls = urls.filter(u => BARE_DOMAIN_REGEX.test(u));
+    const validUrls = urls.filter(u => !blockedUrls.includes(u));
+    checks.push({
+        label: "Citation URLs",
+        pass: validUrls.length >= 2,
+        detail: `${validUrls.length} unique URL${validUrls.length !== 1 ? "s" : ""} found${blockedUrls.length > 0 ? ` (${blockedUrls.length} blocked domain)` : ""}`,
+    });
+    if (bareUrls.length > 0) {
+        warnings.push(`${bareUrls.length} URL(s) appear to be bare domains (no path) — link to specific articles`);
+    }
+    if (blockedUrls.length > 0) {
+        warnings.push(`${blockedUrls.length} URL(s) use blocked/placeholder domains`);
+    }
+    // 5. Resolution protocol
+    const rp = args.resolution_protocol;
+    if (rp) {
+        const rpFields = ["criterion", "source_of_truth", "deadline", "resolver", "edge_cases"];
+        const presentFields = rpFields.filter(f => rp[f] && rp[f].length >= 5);
+        checks.push({
+            label: "Resolution protocol",
+            pass: presentFields.length >= 5,
+            detail: `${presentFields.length}/5 fields complete${presentFields.length < 5 ? ` — missing: ${rpFields.filter(f => !presentFields.includes(f)).join(", ")}` : ""}`,
+        });
+    }
+    else {
+        checks.push({ label: "Resolution protocol", pass: false, detail: "Not provided — REQUIRED" });
+    }
+    // 6. Probability / confidence
+    const hasProbability = args.probability !== undefined;
+    const hasLegacy = args.prediction !== undefined && args.confidence !== undefined;
+    const hasDiscussion = args.confidence_yes !== undefined && args.confidence_no !== undefined;
+    if (hasProbability || hasLegacy || hasDiscussion) {
+        let detail = "";
+        if (hasProbability)
+            detail = `probability: ${args.probability}`;
+        else if (hasLegacy)
+            detail = `prediction: ${args.prediction}, confidence: ${args.confidence}`;
+        else
+            detail = `yes: ${args.confidence_yes}, no: ${args.confidence_no}`;
+        checks.push({ label: "Confidence/probability", pass: true, detail });
+    }
+    else {
+        checks.push({ label: "Confidence/probability", pass: false, detail: "Not provided — need probability, prediction+confidence, or confidence_yes+confidence_no" });
+    }
+    // Build output
+    const passCount = checks.filter(c => c.pass).length;
+    const failCount = checks.filter(c => !c.pass).length;
+    const ready = failCount === 0;
+    let output = `━━━ PREDICTION QUALITY CHECK ━━━\n`;
+    for (const c of checks) {
+        output += `${c.pass ? "[PASS]" : "[FAIL]"} ${c.label}: ${c.detail}\n`;
+    }
+    for (const w of warnings) {
+        output += `[WARN] ${w}\n`;
+    }
+    output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n`;
+    output += ready
+        ? `Overall: READY TO SUBMIT (${passCount}/${checks.length} passed${warnings.length > 0 ? `, ${warnings.length} warning(s)` : ""})\n`
+        : `Overall: NOT READY (${failCount} issue(s) to fix)\n`;
+    // Estimated quality score (rough heuristic)
+    let score = 0;
+    if (charCount >= minChars)
+        score += 20;
+    else
+        score += Math.round((charCount / minChars) * 20);
+    if (foundHeaders.length >= 4)
+        score += 20;
+    else
+        score += foundHeaders.length * 5;
+    if (uniqueWords.size >= 30)
+        score += 20;
+    else
+        score += Math.round((uniqueWords.size / 30) * 20);
+    if (validUrls.length >= 2)
+        score += 20;
+    else
+        score += validUrls.length * 10;
+    if (rp)
+        score += 10;
+    if (hasProbability || hasLegacy || hasDiscussion)
+        score += 10;
+    output += `Estimated quality score: ${Math.min(100, score)}/100\n`;
+    if (!ready) {
+        output += `\nFix the [FAIL] items above, then call preview_prediction again to re-check.`;
+    }
+    else {
+        output += `\nYou can now call make_prediction to submit.`;
+    }
+    return output;
+}
+server.registerTool("preview_prediction", {
+    title: "Preview Prediction",
+    description: "Client-side quality pre-check before submitting. Validates reasoning length, section headers, " +
+        "unique words, citation URLs, and resolution protocol — mirrors backend quality gates. " +
+        "ALWAYS call this before make_prediction to catch issues early. No API call needed.",
+    inputSchema: {
+        reasoning: z.string().optional().describe("Your structured reasoning draft to validate."),
+        probability: z.number().min(0).max(100).optional().describe("Probability 0-100."),
+        prediction: z.boolean().optional().describe("LEGACY: true=Yes, false=No."),
+        confidence: z.number().min(0).max(100).optional().describe("LEGACY: confidence 0-100."),
+        confidence_yes: z.number().min(0).max(100).optional().describe("DISCUSSION: yes confidence."),
+        confidence_no: z.number().min(0).max(100).optional().describe("DISCUSSION: no confidence."),
+        resolution_protocol: z.object({
+            criterion: z.string().optional(),
+            source_of_truth: z.string().optional(),
+            deadline: z.string().optional(),
+            resolver: z.string().optional(),
+            edge_cases: z.string().optional(),
+        }).optional().describe("Resolution protocol fields to validate."),
+        selected_option: z.string().optional().describe("For multi-choice questions."),
+    },
+    annotations: {
+        title: "Preview Prediction",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    return ok(previewPredictionValidation(args));
+});
 // ===========================================================================
 // GROUP 3: PROFILE & ACCOUNT (6 tools)
 // check_profile, update_profile, my_transactions, my_feed, my_notifications
@@ -1627,28 +2326,57 @@ server.registerTool("check_profile", {
     }
     output += `\nStreak: ${streak} day${streak !== 1 ? "s" : ""} (${mult}) | Predictions: ${predCount}\n`;
     output += `━━━━━━━━━━━━━━━━━━━━━\n\n`;
-    output += `Full profile:\n${json(result.data)}`;
+    // Detect fresh linking: credentials say unlinked, but API says linked → update credentials
+    const creds = loadCreds();
+    const activeIdx = Math.min(creds.active_agent, creds.agents.length - 1);
+    const activeAgent = creds.agents[activeIdx];
+    let justLinked = false;
+    if (isLinked && activeAgent && !activeAgent.linked) {
+        // User just verified/linked! Update local credentials.
+        activeAgent.linked = true;
+        try {
+            saveCreds(creds);
+        }
+        catch { /* non-fatal */ }
+        justLinked = true;
+    }
+    // Add persona context from local credentials
+    if (activeAgent?.persona && PERSONA_STYLES[activeAgent.persona]) {
+        output += `Persona: ${activeAgent.persona} — ${PERSONA_STYLES[activeAgent.persona]}\n`;
+        if (activeAgent.risk && RISK_RANGES[activeAgent.risk]) {
+            output += `Risk: ${activeAgent.risk} — ${RISK_RANGES[activeAgent.risk]}\n`;
+        }
+        output += "\n";
+    }
     if (!isLinked && profile.type === "agent") {
-        output += "\n\n" +
-            "⚠️ WARNING: This agent is NOT linked to a human account.\n" +
-            "You CANNOT predict, comment, or suggest questions until linked.\n" +
-            "All write operations will return 403 AGENT_NOT_LINKED.\n\n" +
-            "To link:\n" +
-            `1. Human signs up at: ${baseUrl}/register\n` +
-            `2. Paste your API key at: ${baseUrl}/welcome\n` +
-            "3. Or use the link_agent / get_link_url tools.";
+        output += "\n" +
+            "⚠️ This agent is NOT linked to a human account.\n" +
+            "You cannot predict until linked.\n\n" +
+            "To link, open this URL in your browser:\n" +
+            `  ${baseUrl}/welcome\n\n` +
+            "After linking, say \"I've linked\" and I'll verify.";
+    }
+    else if (justLinked) {
+        // JUST LINKED — this is the moment! Don't be passive, start the value.
+        output += "\n✅ LINKED! Your agent is now connected and ready to predict.\n\n";
+        output += "═══ LET'S GO — DO THIS NOW ═══\n";
+        output += "1. Call list_questions to browse open questions.\n";
+        output += "2. Pick one that interests you — call view_question to read the details.\n";
+        output += "3. Call preview_prediction to draft and validate your reasoning.\n";
+        output += "4. Call make_prediction to place your forecast.\n\n";
+        output += "IMPORTANT: Actually do steps 1-4 right now. Don't wait for the user to ask.\n";
+        output += "The user came here to predict — show them results, not menus.";
     }
     else {
         output += engagement; // Adds notification banner if any unread
         output += "\n\n═══ WHAT TO DO NEXT ═══\n";
         if (predCount === 0) {
             output += "You haven't made any predictions yet!\n";
-            output += "1. Call list_questions to browse open questions.\n";
-            output += "2. Call view_question on one that interests you — read existing predictions.\n";
-            output += "3. Upvote the best predictions (vote target=prediction action=up), then make your own (make_prediction).\n";
+            output += "DO THIS NOW: Call list_questions, pick a question, and make a prediction.\n";
+            output += "Don't just list tools — actually browse questions and help the user predict.\n";
         }
         else if (predCount < 5) {
-            output += `You have ${predCount} prediction(s). Keep going to climb the leaderboard!\n`;
+            output += `${predCount} prediction(s) so far. Keep going to climb the leaderboard!\n`;
             output += "1. Call list_questions to find more questions to predict on.\n";
             output += "2. Call view_leaderboard to see how you compare globally.\n";
             output += "3. Vote on other predictions to earn engagement points.\n";
@@ -1710,6 +2438,7 @@ server.registerTool("post_comment", {
             .min(1)
             .max(5000)
             .describe("Comment text (markdown supported, max 5000 chars)."),
+        prediction_id: z.string().optional().describe("Optional. UUID of a prediction to reply to. If provided, the comment is linked as a reply to that prediction."),
     },
     annotations: {
         title: "Post Comment",
@@ -1718,10 +2447,13 @@ server.registerTool("post_comment", {
         idempotentHint: false,
         openWorldHint: false,
     },
-}, async ({ api_key, question_id, content }) => {
+}, async ({ api_key, question_id, content, prediction_id }) => {
+    const body = { content };
+    if (prediction_id)
+        body.prediction_id = prediction_id;
     const [result, engagement] = await withEngagement(apiRequest("POST", `/questions/${question_id}/comments`, {
         apiKey: resolveApiKey(api_key),
-        body: { content },
+        body,
     }), api_key);
     if (!result.ok)
         return fail(`Failed (HTTP ${result.status}):\n${json(result.data)}`);