sigrank 0.15.3 → 0.15.5

package/README.md

@@ -11,12 +11,12 @@
 For all builders, burners and 10xers.
 
 [![npm version](https://img.shields.io/npm/v/sigrank.svg?style=flat-square&color=gold)](https://www.npmjs.com/package/sigrank)
-[![npm downloads](https://img.shields.io/npm/dm/sigrank.svg?style=flat-square&color=blue)](https://www.npmjs.com/package/sigrank)
 [![CI](https://github.com/SunrisesIllNeverSee/sigrank-mcp/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/SunrisesIllNeverSee/sigrank-mcp/actions/workflows/ci.yml)
 [![license](https://img.shields.io/badge/license-MIT-green.svg?style=flat-square)](./LICENSE)
 [![platform](https://img.shields.io/badge/platform-node-grey.svg?style=flat-square)](https://nodejs.org)
 [![live](https://img.shields.io/badge/board-signalaf.com-gold.svg?style=flat-square)](https://signalaf.com)
 [![SunrisesIllNeverSee/sigrank-mcp MCP server](https://glama.ai/mcp/servers/SunrisesIllNeverSee/sigrank-mcp/badges/score.svg)](https://glama.ai/mcp/servers/SunrisesIllNeverSee/sigrank-mcp)
+[![Smithery](https://smithery.ai/badge/burnmydays/sigrank-mcp)](https://smithery.ai/servers/burnmydays/sigrank-mcp)
 
 </div>
 
@@ -73,6 +73,37 @@ sigrank
 **Repo:** [`SunrisesIllNeverSee/sigrank-mcp`](https://github.com/SunrisesIllNeverSee/sigrank-mcp)
 **Site:** [signalaf.com](https://signalaf.com)
 **npm:** [sigrank](https://www.npmjs.com/package/sigrank)
+**Smithery:** [smithery.ai/servers/burnmydays/sigrank-mcp](https://smithery.ai/servers/burnmydays/sigrank-mcp)
+**Glama:** [glama.ai/mcp/servers/SunrisesIllNeverSee/sigrank-mcp](https://glama.ai/mcp/servers/SunrisesIllNeverSee/sigrank-mcp)
+
+---
+
+## Install via Smithery
+
+SigRank is available on [Smithery](https://smithery.ai/servers/burnmydays/sigrank-mcp) as a stdio MCP bundle — one-click install for Claude Desktop, Cursor, and other MCP clients.
+
+### Smithery CLI
+
+```bash
+# Install Smithery CLI
+npm install -g smithery
+
+# Connect to SigRank (downloads the MCPB bundle locally)
+smithery mcp add burnmydays/sigrank-mcp --id sigrank
+
+# List available tools
+smithery tool list sigrank
+
+# Call a tool
+smithery tool call sigrank get_leaderboard '{}'
+smithery tool call sigrank rank_paste '{"text": "1000000 500000 50000 800000"}'
+```
+
+### Claude Desktop (via Smithery)
+
+1. Go to [smithery.ai/servers/burnmydays/sigrank-mcp](https://smithery.ai/servers/burnmydays/sigrank-mcp)
+2. Click **Install**
+3. Smithery handles the rest — no manual config editing
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.15.3",
+  "version": "0.15.5",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",
   "type": "module",

package/tools.mjs

@@ -165,66 +165,242 @@ export const DEFAULT_FETCH_TIMEOUT = Number(process.env.SIGRANK_FETCH_TIMEOUT) |
  *  past this is malformed or abusive — reject cleanly before parsing/POSTing (E2 hardening). */
 const MAX_INPUT = 1_000_000
 
+// ── Smithery quality: output schemas + annotations ──────────────────────────
+// MCP tool annotations hint to clients about side-effects, read-only status, etc.
+const ANNOTATIONS = {
+  readOnlyHint: { readOnlyHint: true },
+  destructiveHint: { destructiveHint: false },
+  idempotentHint: { idempotentHint: true },
+  openWorldHint: { openWorldHint: false },
+}
+
+// Common output schema for cascade results (rank_paste, simulate_change, etc.)
+const CASCADE_OUTPUT = {
+  type: 'object',
+  properties: {
+    yield_: { type: 'number', description: 'Υ Yield — the headline efficiency metric (Cache Reads × Output / Input²)' },
+    snr: { type: 'number', description: 'Signal-to-noise ratio' },
+    leverage: { type: 'number', description: 'Cr/I — cache reads divided by input' },
+    velocity: { type: 'number', description: 'O/I — output divided by input' },
+    tenx_dev: { type: 'number', description: '10xDEV score' },
+    class: { type: 'string', enum: ['Burner', 'Builder', '10xer'], description: 'Operator class tier' },
+    card: { type: 'string', description: 'Deterministic prose summary of the cascade result' },
+    warnings: { type: 'array', items: { type: 'string' }, description: 'Parse or data warnings if any' },
+  },
+  required: ['yield_', 'class'],
+}
+
+const LEADERBOARD_OUTPUT = {
+  type: 'object',
+  properties: {
+    operators: {
+  type: 'array',
+  description: 'Array of ranked operators sorted by yield',
+  items: {
+    type: 'object',
+    properties: {
+      codename: { type: 'string', description: 'Public display name' },
+      yield_: { type: 'number', description: 'Υ Yield metric' },
+      leverage: { type: 'number', description: 'Cr/I ratio' },
+      velocity: { type: 'number', description: 'O/I ratio' },
+      class: { type: 'string', enum: ['Burner', 'Builder', '10xer'] },
+      rank: { type: 'integer', description: '1-based rank position' },
+    },
+  },
+    },
+  },
+}
+
+const OPERATOR_OUTPUT = {
+  type: 'object',
+  properties: {
+    codename: { type: 'string', description: 'Operator display name' },
+    yield_: { type: 'number', description: 'Υ Yield metric' },
+    leverage: { type: 'number', description: 'Cr/I ratio' },
+    velocity: { type: 'number', description: 'O/I ratio' },
+    class: { type: 'string', enum: ['Burner', 'Builder', '10xer'] },
+    rank: { type: 'integer', description: '1-based rank position' },
+    windows: {
+      type: 'array',
+      description: 'Per-window breakdowns (7d, 30d, 90d, all-time)',
+      items: {
+        type: 'object',
+        properties: {
+          window: { type: 'string', enum: ['7d', '30d', '90d', 'all_time'] },
+          pillars: {
+            type: 'object',
+            properties: {
+              input: { type: 'integer' },
+              output: { type: 'integer' },
+              cacheCreate: { type: 'integer' },
+              cacheRead: { type: 'integer' },
+            },
+          },
+        },
+      },
+    },
+  },
+}
+
+const SUBMIT_OUTPUT = {
+  type: 'object',
+  properties: {
+    status: { type: 'string', enum: ['ok', 'error', 'skipped'], description: 'Submission status' },
+    preview: CASCADE_OUTPUT,
+    server_response: { type: 'object', description: 'Server-side response including new rank if accepted' },
+    reason: { type: 'string', description: 'Error or skip reason if status is not ok' },
+  },
+}
+
+const TOKENPULL_OUTPUT = {
+  type: 'object',
+  properties: {
+    platform: { type: 'string', description: 'Source platform name' },
+    generatedAt: { type: 'string', description: 'ISO timestamp of the pull' },
+    windows: {
+      type: 'array',
+      description: 'Per-window token usage + cascade results',
+      items: {
+        type: 'object',
+        properties: {
+          window: { type: 'string', enum: ['7d', '30d', '90d', 'all'] },
+          pillars: {
+            type: 'object',
+            properties: {
+              input: { type: 'integer' },
+              output: { type: 'integer' },
+              cacheCreate: { type: 'integer' },
+              cacheRead: { type: 'integer' },
+            },
+          },
+          messages: { type: 'integer', description: 'Number of messages in window' },
+          estimated: { type: 'boolean', description: 'True if cacheCreate was estimated' },
+          cascade: CASCADE_OUTPUT,
+        },
+      },
+    },
+  },
+}
+
+const ENROLL_OUTPUT = {
+  type: 'object',
+  properties: {
+    status: { type: 'string', enum: ['enrolled', 'error'], description: 'Enrollment result' },
+    codename: { type: 'string', description: 'Operator codename if enrolled' },
+    operator_id: { type: 'string', description: 'Operator ID if enrolled' },
+    device_id: { type: 'string', description: 'Local device ID' },
+    trust_status: { type: 'string', description: 'Trust level of the device' },
+    reason: { type: 'string', description: 'Error reason if status is error' },
+  },
+}
+
+const COMPARE_OUTPUT = {
+  type: 'object',
+  properties: {
+    platform: { type: 'string' },
+    sources: {
+      type: 'array',
+      description: 'Side-by-side comparison of each token source',
+      items: {
+        type: 'object',
+        properties: {
+          source: { type: 'string', description: 'Source name (tokenpull, ccusage, token-dash, tokscale)' },
+          pillars: { type: 'object' },
+          cascade: CASCADE_OUTPUT,
+          delta_pct: { type: 'object', description: 'Delta % vs tokenpull baseline' },
+        },
+      },
+    },
+  },
+}
+
+const SIMULATE_OUTPUT = {
+  type: 'object',
+  properties: {
+    current: CASCADE_OUTPUT,
+    simulated: CASCADE_OUTPUT,
+    yield_delta: { type: 'number', description: 'Υ Yield change (simulated - current)' },
+    class_change: { type: 'string', description: 'Class tier change description' },
+    metric_diffs: { type: 'object', description: 'Per-metric before/after diffs' },
+  },
+}
+
 export const TOOLS = [
   {
     name: 'rank_paste',
     description:
-      'Rank a paste of ccusage-style token counts to compute your SigRank yield. Accepts JSON {input,output,cacheCreate,cacheRead} or 4 whitespace-separated numbers in that order (input output cacheCreate cacheRead). Returns Υ Yield (the headline efficiency metric), SNR, Leverage ratio (Cr/I), Velocity (O/I), 10xDEV score, operator class tier (Burner/Builder/10xer), and a deterministic prose "card" summarizing the result. All computation is local — no network calls, no prompt data leaves the machine. Use this for a quick one-off ranking without submitting to the board.',
+      'Computes the SigRank yield cascade from a paste of token counts. Parses the input, runs the full cascade math locally (no network calls), and returns: Υ Yield (the headline efficiency metric, Υ = Cache Reads × Output / Input²), SNR (signal-to-noise ratio), Leverage ratio (Cr/I = cache reads divided by input), Velocity (O/I = output divided by input), 10xDEV score, operator class tier (Burner / Builder / 10xer), and a deterministic prose "card" summarizing the result in plain English. Accepts two input formats: (1) JSON object {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} or (2) four whitespace-separated numbers in order: input output cacheCreate cacheRead. Returns an error if the input is malformed or has negative values. Use this for a quick one-off ranking without submitting to the board. Do NOT use this to submit your score — use submit_paste instead, which both ranks and publishes. Do NOT use this if you want to rank all four time windows at once — use rank_windows for that. After calling this, use submit_paste to publish the result if you want to appear on the leaderboard.',
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.destructiveHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
         text: {
           type: 'string',
-          description: 'Token counts to rank. Two formats accepted: (1) JSON object {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} or (2) four whitespace-separated numbers in order: input output cacheCreate cacheRead. Get these from `ccusage` output, the Claude Max dashboard, or any token reader.',
+          description: 'Token counts to rank. Two formats accepted: (1) JSON object {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} where all values are non-negative integers, or (2) four whitespace-separated numbers in order: input output cacheCreate cacheRead. Get these from `ccusage` output, the Claude Max usage dashboard, tokscale, or any token reader. Example valid input: {"input":1000000,"output":500000,"cacheCreate":50000,"cacheRead":800000}',
         },
       },
       required: ['text'],
+      description: 'Requires the token counts as a string. No other parameters are accepted.',
     },
+    outputSchema: CASCADE_OUTPUT,
   },
   {
     name: 'get_leaderboard',
     description:
-      "Fetch the live public SigRank leaderboard from signalaf.com — all ranked operators sorted by yield (Υ = Cache Reads × Output / Input²). Returns each operator's codename, yield, leverage ratio (Cr/I), velocity (O/I), class tier, and rank. Use this to see where operators stand overall or to find specific codenames for get_operator lookups.",
-    inputSchema: { type: 'object', properties: {} },
+      "Fetches the live public SigRank leaderboard from signalaf.com. Reads all ranked operators sorted by yield (Υ = Cache Reads × Output / Input²) and returns an array of operator summaries. Each entry contains: codename (public display name), yield (Υ, the headline efficiency metric), leverage ratio (Cr/I = cache reads divided by input), velocity (O/I = output divided by input), class tier (Burner / Builder / 10xer), and rank position (integer, 1-based). Returns an empty array if no operators have submitted yet. Use this to see where operators stand overall, to find specific codenames for get_operator lookups, or to display the current rankings. Do NOT use this to check your own rank if you already know your codename — use get_operator instead for a single-operator profile with per-window breakdowns. After calling this, follow up with get_operator to get detailed metrics for any operator of interest.",
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
+    inputSchema: {
+      type: 'object',
+      properties: {},
+      description: 'This tool takes no parameters. It always fetches the full public leaderboard.',
+    },
+    outputSchema: LEADERBOARD_OUTPUT,
   },
   {
     name: 'get_operator',
     description:
-      "Fetch one operator's live profile from the SigRank board by their codename. Returns their current yield (Υ), leverage ratio (Cr/I), velocity (O/I), class tier, rank position, and per-window breakdowns (7d/30d/90d/all-time). Use this to look up any operator who has submitted to the board — codenames are public and visible on the leaderboard.",
+      "Fetches one operator's live profile from the SigRank board by their codename. Reads the operator's current submission data from signalaf.com and returns their detailed metrics: yield (Υ), leverage ratio (Cr/I), velocity (O/I), class tier (Burner / Builder / 10xer), rank position (integer, 1-based), and per-window breakdowns for each time range (7d, 30d, 90d, all-time) with the four canonical pillars (input, output, cacheCreate, cacheRead) per window. Returns an error if the codename is not found on the board. Use this to look up any operator who has submitted to the board — codenames are public and visible on the leaderboard. Do NOT use this to browse all operators — use get_leaderboard for that. After calling this, you can use simulate_change to model what would happen if the operator adjusted their token mix.",
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
         codename: {
           type: 'string',
-          description: 'The operator\'s public codename as shown on the SigRank leaderboard (e.g. "Ghost Falcon", "Iron Lotus"). Case-insensitive.',
+          description: 'The operator\'s public codename as shown on the SigRank leaderboard. Case-insensitive — "Ghost Falcon" and "ghost falcon" are equivalent. Must match a codename that exists on the board; returns an error if not found. To discover valid codenames, call get_leaderboard first.',
         },
       },
       required: ['codename'],
+      description: 'Requires the operator\'s codename. No other parameters are accepted.',
     },
+    outputSchema: OPERATOR_OUTPUT,
   },
   {
     name: 'submit_paste',
     description:
-      'Rank a paste of token counts AND publish it to the live SigRank board at signalaf.com in one call. Computes the cascade locally for an instant preview + card, then submits the raw paste to the board\'s web-paste endpoint, which re-parses and re-scores it server-side (the server score is authoritative). A codename is required to publish — omit it for a local preview only. Token-only, no auth required (matches the web paste path). Best with a ccusage JSON paste — the 4-number form ranks locally but the board may reject it.',
+      'Ranks a paste of token counts AND publishes it to the live SigRank board at signalaf.com in one call. First computes the cascade locally for an instant preview (yield, leverage, velocity, class, card), then submits the raw paste to the board\'s web-paste endpoint, which re-parses and re-scores it server-side. The server score is authoritative — it may differ from the local preview if the board applies additional validation. Returns both the local preview and the server response (including the operator\'s new rank if accepted). A codename is required to publish — omit it for a local preview only (no board submission). Token-only, no auth required. Use this when you have token counts from ccusage or a dashboard and want to both see your score and publish it. Do NOT use this if you want to pull your local usage automatically — use tokenpull_submit for the zero-paste flow. Do NOT use this for multi-window dashboard pastes — use rank_windows to rank them first, then submit each window. After calling this, use get_operator with your codename to verify your submission appeared on the board.',
+    annotations: { ...ANNOTATIONS.destructiveHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
         text: {
           type: 'string',
-          description: 'Token counts to rank and submit. Two formats: (1) JSON {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} from ccusage, or (2) four whitespace-separated numbers: input output cacheCreate cacheRead.',
+          description: 'Token counts to rank and submit. Two formats: (1) JSON {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} from ccusage (preferred — the board parses this reliably), or (2) four whitespace-separated numbers: input output cacheCreate cacheRead. The 4-number form ranks locally but the board may reject it. Example: {"input":1000000,"output":500000,"cacheCreate":50000,"cacheRead":800000}',
         },
         codename: {
           type: 'string',
-          description: 'Operator codename to publish under on the leaderboard (e.g. "Ghost Falcon"). Required to submit — omit for local preview only (no board submission).',
+          description: 'Operator codename to publish under on the leaderboard (e.g. "Ghost Falcon"). Required to submit — omit for local preview only (no board submission, just returns the local cascade result). Must be a non-empty string.',
         },
       },
       required: ['text'],
+      description: 'Requires token counts (text). Codename is optional but required for board submission — omit it for preview-only mode.',
     },
+    outputSchema: SUBMIT_OUTPUT,
   },
   {
     name: 'tokenpull',
     description:
       "Pull your LOCAL token usage from the platform's session logs and rank it across the four windows (7d/30d/90d/all-time) with the cascade — zero paste. Token-only: reads usage counts not message content. The numbers stay on your machine unless you submit them. Some platforms may have partial data (estimated=true when cacheCreate isn't available) or a dataGap note when the log format doesn't expose raw token counts.",
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -235,11 +411,13 @@ export const TOOLS = [
         },
       },
     },
+    outputSchema: TOKENPULL_OUTPUT,
   },
   {
     name: 'tokenpull_submit',
     description:
       "Pull your LOCAL token usage from session logs AND publish it to the SigRank board in one call — the zero-paste flow. Reads the four canonical pillars (input, output, cacheCreate, cacheRead) per window from your local logs, computes the cascade, and submits each window to the board where it is re-scored server-side and tagged with the source platform. Requires a codename to publish; omit for a local preview only. Token-only — no prompt content is read or transmitted.",
+    annotations: { ...ANNOTATIONS.destructiveHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -259,11 +437,13 @@ export const TOOLS = [
         },
       },
     },
+    outputSchema: SUBMIT_OUTPUT,
   },
   {
     name: 'rank_windows',
     description:
       'Rank all four time windows (7d/30d/90d/all-time) in one call from a dashboard paste — paste the full table from ccusage, tokscale, or the Claude Max usage dashboard and get the cascade (Υ, SNR, Leverage, Velocity, 10xDEV, class, card) for each window. Each window is parsed and scored independently. Named keys required (input/output/cacheCreate/cacheRead); positional order is NOT safe here (dashboards list cache_read before cache_create — see WINDOWED_PROFILES gotcha). Omit windows you don\'t have — partial input is allowed (1–4 windows). Does NOT submit to the board; use tokenpull_submit for zero-paste publishing.',
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -276,11 +456,28 @@ export const TOOLS = [
       // at least one window paste is required (runtime check backs this up)
       anyOf: [{ required: ['7d'] }, { required: ['30d'] }, { required: ['90d'] }, { required: ['all'] }],
     },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        windows: {
+          type: 'array',
+          description: 'Cascade results per window',
+          items: {
+            type: 'object',
+            properties: {
+              window: { type: 'string', enum: ['7d', '30d', '90d', 'all'] },
+              ...CASCADE_OUTPUT.properties,
+            },
+          },
+        },
+      },
+    },
   },
   {
     name: 'watch_tokenpull',
     description:
       'One poll per call: pulls your local token logs and returns the current cascade for the watched window — the tool never blocks or loops. Re-call at your desired cadence to watch for changes (interval_s is advisory only and echoed back as poll_interval_s). With submit:true (and an enrolled device) each call may also sign + publish the watched window to the board, rate-limited to once per 5 min per platform+window; default is preview-only (no submit).',
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -290,11 +487,13 @@ export const TOOLS = [
         submit:      { type: 'boolean', description: 'auto-submit the watched window to the board as a VERIFIED operator each poll (requires `enroll`; default false = preview only)' },
       },
     },
+    outputSchema: TOKENPULL_OUTPUT,
   },
   {
     name: 'tokenpull_compare',
     description:
       'Pull token usage from ALL four local sources in parallel — tokenpull (JSONL canon), ccusage CLI, token-dashboard SQLite, and tokscale report — and return them side-by-side with delta % vs tokenpull as the baseline. Also computes the cascade (Υ, SNR, Leverage, class) for each source so you can see how each verifier scores. Useful for validating your numbers before submitting, or understanding discrepancies between tools. Claude only for token-dash; codex and others use tokenpull + ccusage + tokscale. Token-only, on-device.',
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -305,11 +504,13 @@ export const TOOLS = [
         },
       },
     },
+    outputSchema: COMPARE_OUTPUT,
   },
   {
     name: 'enroll',
     description:
       'Bind THIS device to your SigRank operator so your signed token runs cascade to the live board. Paste the key from signalaf.com → Settings → "New key" (or "Generate connect code"). On first run it generates + stores a local ed25519 keypair (~/.sigrank-mcp/identity.json); only the PUBLIC key is ever sent. Need a new key? Click "New key" at signalaf.com → Settings, then paste it here.',
+    annotations: { ...ANNOTATIONS.destructiveHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -318,11 +519,13 @@ export const TOOLS = [
       },
       required: ['code'],
     },
+    outputSchema: ENROLL_OUTPUT,
   },
   {
     name: 'submit_verified',
     description:
       'Publish your LOCAL token runs to the SigRank board as a VERIFIED operator — the enrolled, signed path. Reads your pillars (tokenpull), builds the canonical Schema 1.0 snapshot per window, ed25519-signs it with your device key, and POSTs to /api/v1/snapshots. Requires `npx sigrank-mcp enroll` first (a bound device). Only signed submissions from a trusted device rank on the board. Token-only; the private key never leaves your machine. Pass dry_run:true to inspect the exact signed payload without publishing.',
+    annotations: { ...ANNOTATIONS.destructiveHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -331,11 +534,13 @@ export const TOOLS = [
         dry_run: { type: 'boolean', description: 'build + sign but do NOT publish — returns the exact payload that would be POSTed (token counts only), so you can inspect before submitting' },
       },
     },
+    outputSchema: SUBMIT_OUTPUT,
   },
   {
     name: 'simulate_change',
     description:
       "The first PRESCRIPTIVE SigRank tool — 'what if I changed my token mix?' Takes your current 4 pillars (input/output/cacheCreate/cacheRead) and one or more proposed changes, runs the canonical cascade on BOTH the current and simulated values, and returns the exact Υ Yield delta, class change, and per-metric diffs. This is the 'show me the payoff before I do the work' primitive: no network, no submission, pure local math. Use it to answer 'would increasing my cache-read by 50k tokens actually move my class?' before you change your workflow. Accepts the current pillars as JSON or 4 numbers (same as rank_paste) plus a `changes` object with any of the 4 pillar names mapped to new absolute values OR relative deltas (e.g. {cacheRead: '+50000'} or {input: 800000}).",
+    annotations: { ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.idempotentHint, ...ANNOTATIONS.openWorldHint },
     inputSchema: {
       type: 'object',
       properties: {
@@ -356,6 +561,7 @@ export const TOOLS = [
       },
       required: ['text', 'changes'],
     },
+    outputSchema: SIMULATE_OUTPUT,
   },
 ]