@jinn-network/client 0.1.2 → 0.1.3-canary.24b69ea4

package/plugins/jinn-prediction-plugin/mcp/polymarket-server.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const DEFAULT_GAMMA_BASE_URL = 'https://gamma-api.polymarket.com';
+const DEFAULT_CLOB_BASE_URL = 'https://clob.polymarket.com';
+
+const MarketArgsShape = {
+  marketId: z.string().min(1).optional().describe('Exact Polymarket market id from the current prediction task.'),
+  slug: z.string().min(1).optional().describe('Exact Polymarket market slug from the current prediction task URL.'),
+  conditionId: z.string().min(1).optional().describe('Expected condition id from the current prediction task, used only to verify the returned market.'),
+};
+
+const OrderbookArgsShape = {
+  marketId: z.string().min(1).describe('Exact Polymarket market id from the current prediction task.'),
+  conditionId: z.string().min(1).describe('Exact condition id from the current prediction task.'),
+  yesTokenId: z.string().min(1).describe('YES outcome CLOB token id from the current prediction task.'),
+};
+
+const MarketArgsSchema = z.object(MarketArgsShape).strict().refine((args) => args.marketId || args.slug, {
+  message: 'marketId or slug is required',
+});
+
+const OrderbookArgsSchema = z.object(OrderbookArgsShape).strict();
+
+export function listToolDeclarations() {
+  return [
+    {
+      name: 'polymarket_get_market',
+      description:
+        'Read one exact Polymarket binary market named by the current prediction task. Requires marketId or slug and never performs broad market search.',
+      inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          marketId: { type: 'string', description: 'Exact Polymarket market id from the current prediction task.' },
+          slug: { type: 'string', description: 'Exact Polymarket market slug from the current prediction task URL.' },
+          conditionId: { type: 'string', description: 'Expected task condition id for verification.' },
+        },
+      },
+    },
+    {
+      name: 'polymarket_get_orderbook',
+      description:
+        'Read the YES orderbook for the exact market/condition/token identifiers in the current prediction task. Read-only CLOB market data only.',
+      inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['marketId', 'conditionId', 'yesTokenId'],
+        properties: {
+          marketId: { type: 'string', description: 'Exact Polymarket market id from the current prediction task.' },
+          conditionId: { type: 'string', description: 'Exact condition id from the current prediction task.' },
+          yesTokenId: { type: 'string', description: 'YES outcome CLOB token id from the current prediction task.' },
+        },
+      },
+    },
+  ];
+}
+
+function configWithDefaults(config = {}) {
+  return {
+    gammaBaseUrl: config.gammaBaseUrl ?? process.env.POLYMARKET_GAMMA_BASE_URL ?? DEFAULT_GAMMA_BASE_URL,
+    clobBaseUrl: config.clobBaseUrl ?? process.env.POLYMARKET_CLOB_BASE_URL ?? DEFAULT_CLOB_BASE_URL,
+    fetchImpl: config.fetchImpl ?? fetch,
+  };
+}
+
+function apiUrl(baseUrl, path, params = {}) {
+  const url = new URL(path, baseUrl);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+
+async function readJson(url, fetchImpl) {
+  const response = await fetchImpl(url, { method: 'GET' });
+  if (!response.ok) {
+    throw new Error(`Polymarket request failed ${response.status}: ${url}`);
+  }
+  return response.json();
+}
+
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function firstString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === 'string' && value.trim()) return value.trim();
+    if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  }
+  return undefined;
+}
+
+function firstBoolean(record, keys, fallback = false) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'string') {
+      if (value.toLowerCase() === 'true') return true;
+      if (value.toLowerCase() === 'false') return false;
+    }
+  }
+  return fallback;
+}
+
+function parseStringArray(value) {
+  if (Array.isArray(value)) return value.map(String);
+  if (typeof value !== 'string') return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.map(String) : [];
+  } catch {
+    return value.split(',').map((part) => part.trim()).filter(Boolean);
+  }
+}
+
+function normalizeOutcome(value) {
+  return value.trim().toUpperCase();
+}
+
+function decimalString(value, fallback = '0') {
+  if (typeof value === 'number' && Number.isFinite(value)) return value.toFixed(2);
+  if (typeof value === 'string' && value.trim()) return value.trim();
+  return fallback;
+}
+
+function buildMarketUrl(slug) {
+  return slug ? `https://polymarket.com/event/${slug}` : 'https://polymarket.com';
+}
+
+function rulesTextOf(record) {
+  return firstString(record, [
+    'rules',
+    'resolutionRules',
+    'resolution_rules',
+    'description',
+    'question',
+  ]) ?? '';
+}
+
+function endTimeOf(record) {
+  return firstString(record, ['endDateIso', 'endDate', 'end_date', 'endTime', 'end_time']) ?? '';
+}
+
+function tokenIdsFor(record, outcomes) {
+  const ids = parseStringArray(record.clobTokenIds ?? record.clob_token_ids ?? record.tokenIds);
+  if (ids.length < 2) return null;
+  const yesIndex = outcomes.findIndex((outcome) => normalizeOutcome(outcome) === 'YES');
+  const noIndex = outcomes.findIndex((outcome) => normalizeOutcome(outcome) === 'NO');
+  if (yesIndex < 0 || noIndex < 0) return null;
+  const yes = ids[yesIndex];
+  const no = ids[noIndex];
+  return yes && no ? { yes, no } : null;
+}
+
+export function normalizeMarketCandidate(raw) {
+  const record = asRecord(raw);
+  const marketId = firstString(record, ['id', 'marketId', 'market_id']);
+  const conditionId = firstString(record, ['conditionId', 'condition_id']);
+  const slug = firstString(record, ['slug', 'marketSlug', 'eventSlug']) ?? '';
+  const question = firstString(record, ['question', 'title']) ?? '';
+  const outcomes = parseStringArray(record.outcomes).map(normalizeOutcome);
+  const binary = outcomes.length === 2 && outcomes.includes('YES') && outcomes.includes('NO');
+  const tokenIds = binary ? tokenIdsFor(record, outcomes) : null;
+  const endTime = endTimeOf(record);
+
+  if (!marketId || !conditionId || !question || !binary || !tokenIds || !endTime) {
+    return null;
+  }
+
+  const description = firstString(record, ['description']);
+  return {
+    venue: 'polymarket',
+    marketId,
+    conditionId,
+    slug,
+    url: firstString(record, ['url']) ?? buildMarketUrl(slug),
+    question,
+    ...(description ? { description } : {}),
+    rulesText: rulesTextOf(record),
+    endTime,
+    active: firstBoolean(record, ['active'], true),
+    closed: firstBoolean(record, ['closed'], false),
+    archived: firstBoolean(record, ['archived'], false),
+    outcomes: ['YES', 'NO'],
+    tokenIds,
+    liquidityUsd: decimalString(record.liquidity ?? record.liquidityNum ?? record.liquidity_usd),
+    volume24hUsd: decimalString(record.volume24hr ?? record.volume24h ?? record.volume24hUsd ?? record.volume_24h),
+  };
+}
+
+export async function getMarket(args, config = {}) {
+  const parsed = MarketArgsSchema.parse(args);
+  const { gammaBaseUrl, fetchImpl } = configWithDefaults(config);
+  const raw = parsed.marketId
+    ? await readJson(apiUrl(gammaBaseUrl, `/markets/${encodeURIComponent(parsed.marketId)}`), fetchImpl)
+    : await readJson(apiUrl(gammaBaseUrl, `/markets/slug/${encodeURIComponent(parsed.slug)}`), fetchImpl);
+
+  const market = normalizeMarketCandidate(raw);
+  if (!market) throw new Error('Polymarket market response is not an eligible binary market');
+  if (parsed.conditionId && market.conditionId !== parsed.conditionId) {
+    throw new Error(`Polymarket conditionId mismatch: expected ${parsed.conditionId}, got ${market.conditionId}`);
+  }
+  return market;
+}
+
+function timestampToIso(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return new Date(value > 10_000_000_000 ? value : value * 1000).toISOString();
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return timestampToIso(numeric);
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
+  }
+  return new Date().toISOString();
+}
+
+function bestBidAsk(book) {
+  const bids = Array.isArray(book.bids) ? book.bids : [];
+  const asks = Array.isArray(book.asks) ? book.asks : [];
+  const bid = Math.max(...bids.map((row) => Number(asRecord(row).price)).filter(Number.isFinite));
+  const ask = Math.min(...asks.map((row) => Number(asRecord(row).price)).filter(Number.isFinite));
+  if (!Number.isFinite(bid) || !Number.isFinite(ask)) return null;
+  return { bid, ask };
+}
+
+function probability(value) {
+  return Math.max(0, Math.min(1, value)).toFixed(4);
+}
+
+export async function getOrderbook(args, config = {}) {
+  const parsed = OrderbookArgsSchema.parse(args);
+  const { clobBaseUrl, fetchImpl } = configWithDefaults(config);
+  const raw = await readJson(apiUrl(clobBaseUrl, '/book', { token_id: parsed.yesTokenId }), fetchImpl);
+  const book = asRecord(raw);
+  const best = bestBidAsk(book);
+  if (!best) {
+    throw new Error(`Polymarket orderbook has no usable YES bid/ask for token ${parsed.yesTokenId}`);
+  }
+  const midpoint = (best.bid + best.ask) / 2;
+  return {
+    venue: 'polymarket',
+    marketId: parsed.marketId,
+    conditionId: parsed.conditionId,
+    sampledAt: timestampToIso(book.timestamp),
+    bestBidYes: probability(best.bid),
+    bestAskYes: probability(best.ask),
+    midpointYes: probability(midpoint),
+    spread: probability(best.ask - best.bid),
+    source: 'polymarket-clob',
+  };
+}
+
+function ok(data) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+function toolErr(code, message) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify({ error: true, code, message }) }],
+    isError: true,
+  };
+}
+
+export function createPolymarketServer(config = {}) {
+  const server = new McpServer({ name: 'jinn-prediction-polymarket', version: '0.2.0' });
+  const registerTool = server.tool.bind(server);
+
+  registerTool(
+    'polymarket_get_market',
+    listToolDeclarations()[0].description,
+    MarketArgsShape,
+    async (args) => {
+      try {
+        return ok(await getMarket(args, config));
+      } catch (err) {
+        return toolErr('POLYMARKET_MARKET_READ_FAILED', err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+
+  registerTool(
+    'polymarket_get_orderbook',
+    listToolDeclarations()[1].description,
+    OrderbookArgsShape,
+    async (args) => {
+      try {
+        return ok(await getOrderbook(args, config));
+      } catch (err) {
+        return toolErr('POLYMARKET_ORDERBOOK_READ_FAILED', err instanceof Error ? err.message : String(err));
+      }
+    },
+  );
+
+  return server;
+}
+
+export async function startMcpServer(config = {}) {
+  const server = createPolymarketServer(config);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  await new Promise((resolve) => {
+    process.stdin.on('close', resolve);
+    process.stdin.on('end', resolve);
+  });
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  startMcpServer().catch((err) => {
+    console.error(err instanceof Error ? err.stack ?? err.message : String(err));
+    process.exit(1);
+  });
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-solution.schema.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["prediction", "confidence"],
+  "properties": {
+    "prediction": { "type": "number" },
+    "confidence": { "type": "number", "minimum": 0, "maximum": 1 },
+    "rationale": { "type": "string" },
+    "sources": { "type": "array", "items": { "type": "string" } }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-task.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["question", "oracle"],
+  "properties": {
+    "question": {
+      "type": "object",
+      "required": ["kind", "text"],
+      "properties": {
+        "kind": { "enum": ["threshold", "range"] },
+        "text": { "type": "string" }
+      },
+      "additionalProperties": true
+    },
+    "oracle": {
+      "type": "object",
+      "required": ["venue"],
+      "properties": {
+        "venue": { "type": "string" }
+      },
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v0-verdict.schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["verdict", "score"],
+  "properties": {
+    "verdict": { "enum": ["PASS", "FAIL", "REJECTED", "INDETERMINATE"] },
+    "score": { "type": "number", "minimum": 0, "maximum": 1 },
+    "scoreBasis": { "type": "string" }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v1-solution.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["probabilityYes", "submittedAt", "format", "modelId"],
+  "properties": {
+    "probabilityYes": {
+      "type": "string",
+      "pattern": "^(0(\\.\\d+)?|1(\\.0+)?)$"
+    },
+    "submittedAt": { "type": "string", "format": "date-time" },
+    "format": { "const": "decimal" },
+    "modelId": { "type": "string", "minLength": 1 },
+    "confidence": { "enum": ["low", "medium", "high"] },
+    "methodology": { "type": "string" },
+    "evidenceCids": {
+      "type": "array",
+      "items": { "type": "string", "minLength": 1 }
+    },
+    "reasoningCid": { "type": "string", "minLength": 1 },
+    "sourceRefs": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["title", "url"],
+        "properties": {
+          "title": { "type": "string", "minLength": 1 },
+          "url": { "type": "string", "format": "uri" }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v1-task.schema.json

@@ -0,0 +1,118 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["id", "description", "solverType", "role", "window", "claimPolicy", "spec"],
+  "properties": {
+    "id": { "type": "string", "minLength": 1 },
+    "description": { "type": "string", "minLength": 1 },
+    "solverType": { "const": "prediction.v1" },
+    "role": { "enum": ["restoration", "evaluation"] },
+    "window": {
+      "type": "object",
+      "required": ["startTs", "endTs"],
+      "properties": {
+        "startTs": { "type": "number" },
+        "endTs": { "type": "number" }
+      },
+      "additionalProperties": false
+    },
+    "claimPolicy": {
+      "type": "object",
+      "required": ["kind", "maxClaims", "maxClaimsPerSolver", "claimWindow", "selection", "economics"],
+      "properties": {
+        "kind": { "const": "parallel" },
+        "maxClaims": { "type": "integer", "minimum": 1 },
+        "maxClaimsPerSolver": { "type": "integer", "minimum": 1 },
+        "claimWindow": { "const": "task-window" },
+        "selection": { "const": "all-valid-solutions-scored" },
+        "economics": { "const": "testnet-flat" }
+      },
+      "additionalProperties": true
+    },
+    "spec": {
+      "type": "object",
+      "required": ["question", "source", "resolution", "consensusSnapshot", "eligibilitySnapshot"],
+      "properties": {
+        "question": {
+          "type": "object",
+          "required": ["kind", "text", "yesLabel", "noLabel"],
+          "properties": {
+            "kind": { "const": "binary" },
+            "text": { "type": "string", "minLength": 1 },
+            "yesLabel": { "const": "YES" },
+            "noLabel": { "const": "NO" }
+          },
+          "additionalProperties": false
+        },
+        "source": {
+          "type": "object",
+          "required": ["type", "venue", "url", "identifiers"],
+          "properties": {
+            "type": { "const": "prediction-market" },
+            "venue": { "const": "polymarket" },
+            "url": { "type": "string", "format": "uri" },
+            "identifiers": {
+              "type": "object",
+              "required": ["marketId", "conditionId", "yesTokenId", "noTokenId"],
+              "properties": {
+                "marketId": { "type": "string", "minLength": 1 },
+                "conditionId": { "type": "string", "minLength": 1 },
+                "yesTokenId": { "type": "string", "minLength": 1 },
+                "noTokenId": { "type": "string", "minLength": 1 }
+              },
+              "additionalProperties": false
+            }
+          },
+          "additionalProperties": false
+        },
+        "resolution": {
+          "type": "object",
+          "required": ["expectedResolutionTime", "rulesText", "rulesUrl"],
+          "properties": {
+            "expectedResolutionTime": { "type": "string", "format": "date-time" },
+            "rulesText": { "type": "string", "minLength": 1 },
+            "rulesUrl": { "type": "string", "format": "uri" },
+            "timezone": { "type": "string" }
+          },
+          "additionalProperties": false
+        },
+        "consensusSnapshot": {
+          "type": "object",
+          "required": ["sampledAt", "probabilityYes", "method", "bestBidYes", "bestAskYes", "spread", "source"],
+          "properties": {
+            "sampledAt": { "type": "string", "format": "date-time" },
+            "probabilityYes": { "$ref": "#/$defs/probability" },
+            "method": { "const": "best-bid-ask-midpoint" },
+            "bestBidYes": { "$ref": "#/$defs/probability" },
+            "bestAskYes": { "$ref": "#/$defs/probability" },
+            "spread": { "$ref": "#/$defs/probability" },
+            "source": { "const": "polymarket-clob" }
+          },
+          "additionalProperties": false
+        },
+        "eligibilitySnapshot": {
+          "type": "object",
+          "required": ["sampledAt", "timeToResolutionHours", "liquidityUsd", "volume24hUsd", "orderbookAgeSeconds", "selectionReason"],
+          "properties": {
+            "sampledAt": { "type": "string", "format": "date-time" },
+            "timeToResolutionHours": { "type": "number" },
+            "liquidityUsd": { "type": "string" },
+            "volume24hUsd": { "type": "string" },
+            "orderbookAgeSeconds": { "type": "number", "minimum": 0 },
+            "selectionReason": { "type": "string", "minLength": 1 }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "eligibility": { "type": "object" }
+  },
+  "$defs": {
+    "probability": {
+      "type": "string",
+      "pattern": "^(0(\\.\\d+)?|1(\\.0+)?)$"
+    }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/schemas/prediction-v1-verdict.schema.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["verdict", "resolutionSource", "task", "solutionEnvelope", "benchmark", "checks"],
+  "properties": {
+    "verdict": { "enum": ["SCORED", "REJECTED", "INVALID", "INDETERMINATE"] },
+    "outcome": { "enum": ["YES", "NO", "INVALID"] },
+    "resolvedAt": { "type": "string", "format": "date-time" },
+    "resolutionSource": {
+      "type": "object",
+      "required": ["venue", "url", "marketId", "conditionId"],
+      "properties": {
+        "venue": { "const": "polymarket" },
+        "url": { "type": "string", "format": "uri" },
+        "marketId": { "type": "string", "minLength": 1 },
+        "conditionId": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "task": {
+      "type": "object",
+      "required": ["cid", "id"],
+      "properties": {
+        "cid": { "type": "string" },
+        "id": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "solutionEnvelope": {
+      "type": "object",
+      "required": ["cid", "sha256"],
+      "properties": {
+        "cid": { "type": "string" },
+        "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" }
+      },
+      "additionalProperties": false
+    },
+    "claimed": {
+      "type": "object",
+      "required": ["probabilityYes", "submittedAt", "modelId"],
+      "properties": {
+        "probabilityYes": { "type": "string", "pattern": "^(0(\\.\\d+)?|1(\\.0+)?)$" },
+        "submittedAt": { "type": "string", "format": "date-time" },
+        "modelId": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": false
+    },
+    "benchmark": {
+      "type": "object",
+      "required": ["probabilityYes", "sampledAt", "method"],
+      "properties": {
+        "probabilityYes": { "type": "string", "pattern": "^(0(\\.\\d+)?|1(\\.0+)?)$" },
+        "sampledAt": { "type": "string", "format": "date-time" },
+        "method": { "const": "best-bid-ask-midpoint" }
+      },
+      "additionalProperties": false
+    },
+    "scores": {
+      "type": "object",
+      "required": ["scoreBasis", "solverBrier", "consensusBrier", "brierSpread"],
+      "properties": {
+        "scoreBasis": { "const": "brier-loss.v1" },
+        "solverBrier": { "type": "string" },
+        "consensusBrier": { "type": "string" },
+        "brierSpread": { "type": "string" }
+      },
+      "additionalProperties": false
+    },
+    "checks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["name", "status"],
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "status": { "enum": ["PASS", "FAIL", "SKIP", "INDETERMINATE"] },
+          "detail": {}
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": true
+}

package/plugins/jinn-prediction-plugin/skills/base-rate-forecasting/SKILL.md

@@ -0,0 +1,3 @@
+# Base-Rate Forecasting
+
+Use reference classes before inside-view adjustments. State the base rate, the adjustment, and the final probability.

package/plugins/jinn-prediction-plugin/skills/calibration/SKILL.md

@@ -0,0 +1,3 @@
+# Calibration
+
+Express uncertainty numerically. Prefer calibrated probability ranges and identify the evidence that would move the forecast.

package/plugins/jinn-prediction-plugin/skills/common-biases/SKILL.md

@@ -0,0 +1,3 @@
+# Common Forecasting Biases
+
+Check for recency bias, availability bias, anchoring on the market price, motivated reasoning, and overreaction to thin evidence. Name the adjustment only when it changes the final probability.

package/plugins/jinn-prediction-plugin/skills/polymarket-task-handling/SKILL.md

@@ -0,0 +1,5 @@
+# Polymarket Task Handling
+
+Use only the market and orderbook identifiers in the current prediction task. Verify the question text, resolution rules, expected close time, spread, and liquidity before adjusting from the consensus snapshot.
+
+Do not search for unrelated markets, infer from ticker-like names alone, trade, sign orders, use wallet credentials, or post externally. The Polymarket MCP tools are read-only references for task-scoped market data.

package/plugins/jinn-prediction-plugin/skills/prediction-corpus-retrieval/SKILL.md

@@ -0,0 +1,35 @@
+# Prediction Corpus Retrieval
+
+Use this skill when forecasting a `prediction.v1` Task with Network Tools available. The Prediction plugin supplies Polymarket market/orderbook tools; Network Tools supplies generic Jinn task, record, and artifact tools.
+
+## Workflow
+
+1. Call `get_task` first and anchor every lookup to the current Task. Extract the `solverType`, venue, question text, `conditionId`, `marketId`, token ids, expected resolution time, and consensus snapshot.
+2. Call `polymarket_get_market` and `polymarket_get_orderbook` for the task's own market identifiers. Use them to verify the current market state, liquidity, spread, rules, and consensus probability.
+3. Use `search_records` to look for prior Jinn corpus records relevant to the current Task. Prefer queries that include `prediction.v1`, the exact `conditionId`, the Polymarket venue, the market/question text, and resolution or category terms from the task.
+4. Use `inspect_record` on the most promising record, envelope, or projection refs before relying on them. Search and inspect are read-only; they do not acquire artifacts and they do not create a payment.
+5. Consider `acquire_artifact` only when the inspected record shows that full artifact contents are necessary for the forecast. Treat acquisition as explicit, optional, and price-aware. `acquire_artifact` is the only acquisition/payment path; search and inspect never buy or fetch full paid artifacts. Check the quoted price first, avoid paid acquisition unless the expected forecast value justifies it, and record why it was worth acquiring.
+6. Forecast normally using task facts, Polymarket data, base rates, calibration, and the useful corpus evidence. Do not copy a prior probability blindly.
+
+## Ranking Guidance
+
+Prefer records that match the current task directly:
+
+- exact `conditionId` match
+- same venue/source, especially Polymarket
+- same or very similar market/question text
+- scored Verdicts with known outcomes and Brier results
+- Solutions that cite their evidence clearly
+- recent examples with comparable resolution windows, liquidity, spread, or market category
+
+Also inspect failures, rejections, invalid Verdicts, and underperforming forecasts when they are task-relevant. They can warn about ambiguous rules, stale consensus snapshots, thin liquidity, bad search terms, or reasoning patterns that should not be repeated.
+
+## Output Expectations
+
+When corpus evidence affects the forecast, cite the relevant record, envelope, projection, or artifact refs in the reasoning. Separate current Polymarket evidence from prior Jinn corpus evidence, and state whether each prior record raised confidence, lowered confidence, or served as a warning.
+
+Write `.execute/prediction-corpus-retrieval.json` when retrieval is attempted. Keep it as transparent run evidence, not hidden policy. Include the search intents or queries tried, records considered, refs inspected, records cited or used, acquired artifacts with price/payment metadata, forecast probability, consensus snapshot reference, and a short self-assessment of whether retrieval affected the forecast. Search and inspect remain read-only; only `acquire_artifact` should appear for explicit artifact acquisition.
+
+When a later Debrief can connect the run to a Verdict, write `.debrief/learner-feedback.json` with the same retrieval/tool/skill usage plus Verdict or Brier feedback. Do not implement local optimization, ELO, hill-climbing, or strategy mutation inside this skill; the artifact is for future learners and builder-specific improvement systems.
+
+Do not treat any plugin as protocol authority. Task schemas, Solution schemas, Verdict schemas, evaluation, and aggregation semantics come from the SolverNet contract registry. Plugins provide runtime tools and skills only.