otto-intel-mcp 0.1.0

package/dist/prepared-artifacts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * prepared-artifacts.ts — the artifacts THIS process prepared, for the delegated-send path.
+ *
+ * Otto is the submitter on `otto_submit_under_delegation`, so the per-artifact idempotency record (sent →
+ * replayed, halted → never retried) must be authoritative for every artifact the tool accepts. That
+ * record is process-local, and a rolling replacement runs two processes at once: an artifact prepared and
+ * SENT through process A after process B booted has no record on B, and B would send it again. A
+ * boot-time fence ("refuse artifacts older than this process") does not cover that overlap.
+ *
+ * The rule that does: the delegated tool accepts ONLY artifacts this process prepared — by id AND by the
+ * envelope's whole-envelope commitment (`submission.artifact_digest`), so a re-IDed envelope prepared
+ * elsewhere and recommitted under an id this process minted is refused too. Every hosted
+ * `otto_prepare_swap` records its artifact here (when delegation is configured); the delegated tool refuses
+ * anything it does not find (`ARTIFACT_NOT_PREPARED_HERE`) before reading anything. "The submission record
+ * exists on the process that submits" then holds by construction: prepare and submit land on the same
+ * process, or the submit is refused and the caller prepares again — rare (only when prepare → submit spans
+ * a deploy), fail-closed by design, no database, no cross-process state.
+ *
+ * LIVE ENTRIES ARE NEVER EVICTED. An entry lives for the artifact's freshness window plus the submission
+ * grace — exactly as long as its submission record can — and is removed only by that expiry. The registry
+ * is bounded by refusing a NEW prepare at capacity (`PREPARED_ARTIFACT_CAPACITY`), never by dropping an
+ * artifact already issued: an issued artifact that was SENT or HALTED must always find its record and
+ * replay, which it cannot if its prepared-here entry vanished first. Entries are inserted in prepare order
+ * with a constant TTL, so insertion order is expiry order and the sweep stops at the first live entry.
+ */
+/** How long after `valid_until` a submission record — and the prepared-here entry it needs — is kept. */
+export declare const DELEGATED_SUBMISSION_GRACE_MS: number;
+/** Hard bound on LIVE entries per registry; at capacity a new prepare is refused (nothing issued is dropped). */
+export declare const PREPARED_ARTIFACTS_MAX_ENTRIES = 100000;
+/**
+ * Record an artifact this process just prepared; it stays submittable here until `validUntilMs` + grace.
+ * An id is issued once: the same id with the same commitment is a no-op (the first record stands, which
+ * keeps the append-only expiry order); the same id with DIFFERENT content is an entropy collision and the
+ * prepare is refused rather than issuing an artifact this registry cannot vouch for. Refuses at capacity —
+ * the caller's prepare fails, and nothing already issued is touched.
+ */
+export declare function recordPreparedArtifact(owner: object, artifactId: string, commitment: string, validUntilMs: number, nowMs: number): void;
+/**
+ * True only for an artifact THIS process prepared — same id, same commitment — whose window (+ grace) has
+ * not passed. The expiry is checked here as well as by the sweep, so an entry a backwards clock left
+ * behind a live one never answers past its window.
+ */
+export declare function preparedHere(owner: object, artifactId: string, commitment: string, nowMs: number): boolean;
+/** How many live entries the registry holds (tests). */
+export declare function preparedArtifactCount(owner: object, nowMs: number): number;

package/dist/prepared-artifacts.js

@@ -0,0 +1,92 @@
+/**
+ * prepared-artifacts.ts — the artifacts THIS process prepared, for the delegated-send path.
+ *
+ * Otto is the submitter on `otto_submit_under_delegation`, so the per-artifact idempotency record (sent →
+ * replayed, halted → never retried) must be authoritative for every artifact the tool accepts. That
+ * record is process-local, and a rolling replacement runs two processes at once: an artifact prepared and
+ * SENT through process A after process B booted has no record on B, and B would send it again. A
+ * boot-time fence ("refuse artifacts older than this process") does not cover that overlap.
+ *
+ * The rule that does: the delegated tool accepts ONLY artifacts this process prepared — by id AND by the
+ * envelope's whole-envelope commitment (`submission.artifact_digest`), so a re-IDed envelope prepared
+ * elsewhere and recommitted under an id this process minted is refused too. Every hosted
+ * `otto_prepare_swap` records its artifact here (when delegation is configured); the delegated tool refuses
+ * anything it does not find (`ARTIFACT_NOT_PREPARED_HERE`) before reading anything. "The submission record
+ * exists on the process that submits" then holds by construction: prepare and submit land on the same
+ * process, or the submit is refused and the caller prepares again — rare (only when prepare → submit spans
+ * a deploy), fail-closed by design, no database, no cross-process state.
+ *
+ * LIVE ENTRIES ARE NEVER EVICTED. An entry lives for the artifact's freshness window plus the submission
+ * grace — exactly as long as its submission record can — and is removed only by that expiry. The registry
+ * is bounded by refusing a NEW prepare at capacity (`PREPARED_ARTIFACT_CAPACITY`), never by dropping an
+ * artifact already issued: an issued artifact that was SENT or HALTED must always find its record and
+ * replay, which it cannot if its prepared-here entry vanished first. Entries are inserted in prepare order
+ * with a constant TTL, so insertion order is expiry order and the sweep stops at the first live entry.
+ */
+import { refuse } from './execution-errors.js';
+/** How long after `valid_until` a submission record — and the prepared-here entry it needs — is kept. */
+export const DELEGATED_SUBMISSION_GRACE_MS = 10 * 60_000;
+/** Hard bound on LIVE entries per registry; at capacity a new prepare is refused (nothing issued is dropped). */
+export const PREPARED_ARTIFACTS_MAX_ENTRIES = 100_000;
+/** One registry per owner (the delegation services instance); keyed by identity, so a test world is its own process. */
+const REGISTRIES = new WeakMap();
+function registryOf(owner, nowMs) {
+    let entries = REGISTRIES.get(owner);
+    if (!entries) {
+        entries = new Map();
+        REGISTRIES.set(owner, entries);
+    }
+    // Insertion order is expiry order (constant TTL from a monotonic clock): sweep from the front, stop at
+    // the first live entry — O(expired), not O(live), per call.
+    for (const [id, entry] of entries) {
+        if (entry.expiresAtMs > nowMs)
+            break;
+        entries.delete(id);
+    }
+    return entries;
+}
+/**
+ * Record an artifact this process just prepared; it stays submittable here until `validUntilMs` + grace.
+ * An id is issued once: the same id with the same commitment is a no-op (the first record stands, which
+ * keeps the append-only expiry order); the same id with DIFFERENT content is an entropy collision and the
+ * prepare is refused rather than issuing an artifact this registry cannot vouch for. Refuses at capacity —
+ * the caller's prepare fails, and nothing already issued is touched.
+ */
+export function recordPreparedArtifact(owner, artifactId, commitment, validUntilMs, nowMs) {
+    const entries = registryOf(owner, nowMs);
+    const existing = entries.get(artifactId);
+    if (existing) {
+        if (existing.commitment === commitment)
+            return; // the same artifact again: nothing to change
+        // An id collision with DIFFERENT content: never issue an artifact this registry cannot vouch for.
+        return refuse('ARTIFACT_ID_COLLISION', 'the prepare minted an artifact id this server already holds for different content; prepare again');
+    }
+    if (entries.size >= PREPARED_ARTIFACTS_MAX_ENTRIES) {
+        // The rare path: a clock that stepped backwards can leave an expired entry behind a live one, past
+        // the front sweep. Sweep everything once before refusing, so capacity counts LIVE entries only.
+        for (const [id, entry] of entries)
+            if (entry.expiresAtMs <= nowMs)
+                entries.delete(id);
+        if (entries.size >= PREPARED_ARTIFACTS_MAX_ENTRIES) {
+            return refuse('PREPARED_ARTIFACT_CAPACITY', `this server holds its maximum of ${PREPARED_ARTIFACTS_MAX_ENTRIES} live prepared artifacts; retry after some expire`);
+        }
+    }
+    entries.set(artifactId, {
+        expiresAtMs: validUntilMs + DELEGATED_SUBMISSION_GRACE_MS,
+        commitment,
+    });
+}
+/**
+ * True only for an artifact THIS process prepared — same id, same commitment — whose window (+ grace) has
+ * not passed. The expiry is checked here as well as by the sweep, so an entry a backwards clock left
+ * behind a live one never answers past its window.
+ */
+export function preparedHere(owner, artifactId, commitment, nowMs) {
+    const entry = registryOf(owner, nowMs).get(artifactId);
+    return entry !== undefined && entry.expiresAtMs > nowMs && entry.commitment === commitment;
+}
+/** How many live entries the registry holds (tests). */
+export function preparedArtifactCount(owner, nowMs) {
+    return registryOf(owner, nowMs).size;
+}
+//# sourceMappingURL=prepared-artifacts.js.map

package/dist/stdio-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import 'dotenv/config';

package/dist/stdio-main.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { bootFailureLine } from './boot-redaction.js';
+import { loadLocalX402Config } from './local-config.js';
+import { createIntelMcpServer } from './mcp-server.js';
+import { createExecutionToolRuntimeFromEnv } from './execution-tools.js';
+import { X402ReadSource } from './x402-read-source.js';
+async function main() {
+    const source = new X402ReadSource(loadLocalX402Config());
+    const server = createIntelMcpServer(source, createExecutionToolRuntimeFromEnv());
+    await server.connect(new StdioServerTransport());
+}
+main().catch((error) => {
+    // Boot errors here can carry X402_RPC_URL / X402_BASE_URL (viem embeds the transport URL) —
+    // the shared redacting formatter is the only allowed boot printer (c2 fold 08-30).
+    process.stderr.write(bootFailureLine('otto Intel MCP failed', error));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=stdio-main.js.map

package/dist/tool-definitions.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export type IntelToolName = `otto_${string}`;
+export type ToolArguments = Record<string, unknown>;
+export interface IntelToolDefinition {
+    readonly name: IntelToolName;
+    readonly title: string;
+    readonly description: string;
+    readonly endpointId: string;
+    readonly publicPath: `/${string}`;
+    readonly inputSchema: z.ZodObject;
+    readonly priceUsd: string;
+    readonly maxPaymentAtomic: bigint;
+    readonly toQuery: (input: ToolArguments) => Record<string, string>;
+}
+/**
+ * The single v1 catalog consumed by both the hosted and stdio transports.
+ * Every entry is quote/data-only and backed by the data-endpoints service.
+ */
+export declare const TOOL_DEFINITIONS: readonly IntelToolDefinition[];
+export declare const TOOL_DEFINITION_BY_NAME: Map<`otto_${string}`, IntelToolDefinition>;

package/dist/tool-definitions.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+const noArgumentsSchema = z.object({}).strict();
+const thesisSchema = z
+    .object({
+    thesis: z
+        .string()
+        .trim()
+        .min(1, 'thesis must not be blank')
+        .max(200, 'thesis must be at most 200 characters')
+        .optional()
+        .describe('Natural-language screening thesis, for example "AI infrastructure chips".'),
+})
+    .strict();
+const tickerSchema = z
+    .object({
+    ticker: z
+        .string()
+        .trim()
+        .min(1)
+        .max(11)
+        .regex(/^\$?[A-Za-z][A-Za-z.-]{0,9}$/, 'ticker must be a US stock symbol')
+        .describe('US-listed stock ticker, for example NVDA, AAPL, or JPM.'),
+})
+    .strict();
+const managerSchema = z
+    .object({
+    manager: z
+        .string()
+        .trim()
+        .min(1)
+        .max(11)
+        .regex(/^\$?[A-Za-z0-9][A-Za-z0-9.-]{0,9}$/, 'manager must be an SEC CIK or manager ticker')
+        .describe('SEC manager CIK, such as 1067983, or listed manager ticker, such as BLK.'),
+})
+    .strict();
+function noQuery() {
+    return {};
+}
+function tickerQuery(input) {
+    return { ticker: String(input.ticker).replace(/^\$/, '').toUpperCase() };
+}
+function managerQuery(input) {
+    return { manager: String(input.manager).replace(/^\$/, '') };
+}
+function thesisQuery(input) {
+    return typeof input.thesis === 'string' ? { thesis: input.thesis } : {};
+}
+function usdcAtomic(priceUsd) {
+    if (!/^\d+\.\d{1,6}$/.test(priceUsd)) {
+        throw new Error(`invalid USDC price: ${priceUsd}`);
+    }
+    const [whole, fraction] = priceUsd.split('.');
+    return BigInt(whole) * 1000000n + BigInt(fraction.padEnd(6, '0'));
+}
+function defineTool(definition) {
+    return Object.freeze({
+        ...definition,
+        publicPath: definition.publicPath ?? `/${definition.endpointId}`,
+        maxPaymentAtomic: usdcAtomic(definition.priceUsd),
+    });
+}
+/**
+ * The single v1 catalog consumed by both the hosted and stdio transports.
+ * Every entry is quote/data-only and backed by the data-endpoints service.
+ */
+export const TOOL_DEFINITIONS = Object.freeze([
+    defineTool({
+        name: 'otto_tokenized_equities',
+        title: 'Otto tokenized equities',
+        description: 'Scan the live registry of US equities and ETFs tokenized on Robinhood Chain (4663): symbol, canonical token address, decimals, reference price, and verifiable tradability signal. An optional thesis returns a relevance-ranked shortlist with a match reason per row. Data only; not a recommendation or executable quote.',
+        endpointId: 'tokenized-equities',
+        inputSchema: thesisSchema,
+        priceUsd: '0.001',
+        toQuery: thesisQuery,
+    }),
+    defineTool({
+        name: 'otto_rh_season',
+        title: 'Otto Robinhood Chain season',
+        description: 'Scan rug-screened Robinhood Chain (4663) movers with honeypot filters and per-token risk flags. Market context only; not a pick, recommendation, or trade instruction.',
+        endpointId: 'rh-season',
+        inputSchema: noArgumentsSchema,
+        priceUsd: '0.001',
+        toQuery: noQuery,
+    }),
+    defineTool({
+        name: 'otto_equity_intel',
+        title: 'Otto equity intelligence',
+        description: 'Read SEC-EDGAR fundamentals and filings context for a US ticker: revenue and net-income trends, margins, EPS, leverage, recent 10-K/10-Q/8-K filings, and a guarded AI summary. Fundamentals scanner only; not a price feed or recommendation.',
+        endpointId: 'equity-intel',
+        inputSchema: tickerSchema,
+        priceUsd: '0.003',
+        toQuery: tickerQuery,
+    }),
+    defineTool({
+        name: 'otto_insider_trades',
+        title: 'Otto insider trades',
+        description: 'Read parsed SEC Form 4 insider transactions for a US ticker, including purchase/sale counts, dollar values, roles, and net P/S balance. Filing scanner only; not a recommendation.',
+        endpointId: 'insider-trades',
+        inputSchema: tickerSchema,
+        priceUsd: '0.003',
+        toQuery: tickerQuery,
+    }),
+    defineTool({
+        name: 'otto_institutional_holdings',
+        title: 'Otto institutional holdings',
+        description: 'Read the latest SEC 13F-HR top positions for an institutional manager by CIK or manager ticker, with amendments applied. Ownership data only; not a recommendation.',
+        endpointId: 'institutional-holdings',
+        inputSchema: managerSchema,
+        priceUsd: '0.003',
+        toQuery: managerQuery,
+    }),
+    defineTool({
+        name: 'otto_equity_smart_money',
+        title: 'Otto equity smart-money scanner',
+        description: 'Read a public-domain SEC bundle for a US ticker: Form 4 insider activity plus trailing-twelve-month XBRL fundamentals. Scanner context only; not a pick or recommendation.',
+        endpointId: 'equity-smart-money',
+        inputSchema: tickerSchema,
+        priceUsd: '0.006',
+        toQuery: tickerQuery,
+    }),
+    defineTool({
+        name: 'otto_equity_smart_money_brief',
+        title: 'Otto equity smart-money brief',
+        description: 'Read one guarded AI brief over observed SEC Form 4 flow, 13D/13G ownership events, and fundamentals for a US ticker. Filing scanner only; generation rejects buy/sell advice and the result is not a recommendation.',
+        endpointId: 'equity-smart-money-brief',
+        inputSchema: tickerSchema,
+        priceUsd: '0.10',
+        toQuery: tickerQuery,
+    }),
+    defineTool({
+        name: 'otto_base_season',
+        title: 'Otto Base season',
+        description: 'Scan quality-screened Base tokens with current social-intelligence and trusted-KOL context. Market context only; not a pick, recommendation, or trade instruction.',
+        endpointId: 'base-season',
+        inputSchema: noArgumentsSchema,
+        // Phase-3 floor experiment: /base-season serves $0.002. The stdio selector treats this as a maximum
+        // (x402-read-source.ts) but the HOSTED source Railway runs requires amount === this
+        // (hosted-payment-source.ts), so it must ship WITH the price; guard: scripts/audit/client-price-caps.mjs.
+        priceUsd: '0.002',
+        toQuery: noQuery,
+    }),
+    defineTool({
+        name: 'otto_pm_markets',
+        title: 'Otto prediction-market context',
+        description: 'Read the highest-volume open Polymarket markets with live outcome probabilities, bid/ask context, liquidity, volume, and end dates. Event-probability context only; not a recommendation.',
+        endpointId: 'pm-markets',
+        inputSchema: noArgumentsSchema,
+        priceUsd: '0.001',
+        toQuery: noQuery,
+    }),
+    defineTool({
+        name: 'otto_pm_crypto',
+        title: 'Otto crypto prediction-market context',
+        description: 'Read high-volume open BTC, ETH, and crypto Polymarket markets with current outcome probabilities and market context. Event-probability data only; not a recommendation.',
+        endpointId: 'pm-crypto',
+        inputSchema: noArgumentsSchema,
+        priceUsd: '0.001',
+        toQuery: noQuery,
+    }),
+]);
+export const TOOL_DEFINITION_BY_NAME = new Map(TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
+//# sourceMappingURL=tool-definitions.js.map

package/dist/x402-read-source.d.ts

@@ -0,0 +1,11 @@
+import type { SelectPaymentRequirements } from '@x402/axios';
+import type { LocalX402Config } from './local-config.js';
+import type { IntelDataSource } from './data-source.js';
+import type { IntelToolDefinition, ToolArguments } from './tool-definitions.js';
+export declare function boundedPaymentSelector(maxPaymentAtomic: bigint): SelectPaymentRequirements;
+export declare class X402ReadSource implements IntelDataSource {
+    private readonly config;
+    private readonly scheme;
+    constructor(config: LocalX402Config);
+    read(definition: IntelToolDefinition, input: ToolArguments): Promise<unknown>;
+}

package/dist/x402-read-source.js

@@ -0,0 +1,77 @@
+import axios from 'axios';
+import { wrapAxiosWithPayment, x402Client } from '@x402/axios';
+import { ExactEvmScheme } from '@x402/evm/exact/client';
+import { toClientEvmSigner } from '@x402/evm';
+import { createPublicClient, http } from 'viem';
+import { base } from 'viem/chains';
+import { privateKeyToAccount } from 'viem/accounts';
+import { WarmReadUnavailableError, X402PaymentError } from './errors.js';
+const BASE_NETWORK = 'eip155:8453';
+const BASE_USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+function amountOf(requirement) {
+    if (!/^\d+$/.test(requirement.amount))
+        return null;
+    try {
+        return BigInt(requirement.amount);
+    }
+    catch {
+        return null;
+    }
+}
+export function boundedPaymentSelector(maxPaymentAtomic) {
+    return (_version, requirements) => {
+        const eligible = requirements
+            .map((requirement) => ({ requirement, amount: amountOf(requirement) }))
+            .filter((candidate) => candidate.amount !== null &&
+            candidate.amount > 0n &&
+            candidate.amount <= maxPaymentAtomic &&
+            candidate.requirement.scheme === 'exact' &&
+            candidate.requirement.network === BASE_NETWORK &&
+            candidate.requirement.asset.toLowerCase() === BASE_USDC &&
+            /^0x[a-fA-F0-9]{40}$/.test(candidate.requirement.payTo))
+            .sort((left, right) => left.amount < right.amount ? -1 : left.amount > right.amount ? 1 : 0);
+        const selected = eligible[0];
+        if (!selected)
+            throw new Error('No bounded Base USDC payment requirement is available');
+        return selected.requirement;
+    };
+}
+export class X402ReadSource {
+    config;
+    scheme;
+    constructor(config) {
+        this.config = config;
+        const account = privateKeyToAccount(config.privateKey);
+        const publicClient = createPublicClient({
+            chain: base,
+            transport: http(config.rpcUrl),
+        });
+        const signer = toClientEvmSigner(account, publicClient);
+        this.scheme = new ExactEvmScheme(signer);
+    }
+    async read(definition, input) {
+        const paymentClient = new x402Client(boundedPaymentSelector(definition.maxPaymentAtomic));
+        paymentClient.register('eip155:*', this.scheme);
+        const httpClient = wrapAxiosWithPayment(axios.create({
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeoutMs,
+            maxRedirects: 0,
+            headers: { Accept: 'application/json' },
+        }), paymentClient);
+        try {
+            const response = await httpClient.get(definition.publicPath, {
+                params: definition.toQuery(input),
+            });
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error) && error.response?.status === 503) {
+                const rawRetry = error.response.headers?.['retry-after'];
+                const parsedRetry = Number(rawRetry);
+                throw new WarmReadUnavailableError(Number.isFinite(parsedRetry) && parsedRetry > 0 ? Math.ceil(parsedRetry) : undefined);
+            }
+            throw new X402PaymentError();
+        }
+    }
+}
+//# sourceMappingURL=x402-read-source.js.map

package/package.json

@@ -0,0 +1,162 @@
+{
+  "name": "otto-intel-mcp",
+  "version": "0.1.0",
+  "description": "Read-only otto market intelligence MCP server for hosted and local x402 use",
+  "type": "module",
+  "bin": {
+    "otto-intel-mcp": "./dist/stdio-main.js"
+  },
+  "files": [
+    "dist/artifact-id.js",
+    "dist/data-source.js",
+    "dist/errors.js",
+    "dist/execution-config.js",
+    "dist/execution-errors.js",
+    "dist/execution-registration.js",
+    "dist/execution-tool-definitions.js",
+    "dist/execution-tools.js",
+    "dist/execution-types.js",
+    "dist/hyperliquid-info-client.js",
+    "dist/hyperliquid-order-assertions.js",
+    "dist/hyperliquid-order-builder.js",
+    "dist/lifi-bridge-assertions.js",
+    "dist/lifi-execution-client.js",
+    "dist/lifi-fee-assertions.js",
+    "dist/lifi-swap-assertions.js",
+    "dist/polymarket-clob-client.js",
+    "dist/polymarket-order-assertions.js",
+    "dist/polymarket-order-builder.js",
+    "dist/local-config.js",
+    "dist/mcp-server.js",
+    "dist/stdio-main.js",
+    "dist/tool-definitions.js",
+    "dist/x402-read-source.js",
+    "README.md",
+    "LICENSE",
+    "dist/execution-index.js",
+    "dist/artifact-id.d.ts",
+    "dist/data-source.d.ts",
+    "dist/errors.d.ts",
+    "dist/execution-config.d.ts",
+    "dist/execution-errors.d.ts",
+    "dist/execution-registration.d.ts",
+    "dist/execution-tool-definitions.d.ts",
+    "dist/execution-tools.d.ts",
+    "dist/execution-types.d.ts",
+    "dist/hyperliquid-info-client.d.ts",
+    "dist/hyperliquid-order-assertions.d.ts",
+    "dist/hyperliquid-order-builder.d.ts",
+    "dist/lifi-bridge-assertions.d.ts",
+    "dist/lifi-execution-client.d.ts",
+    "dist/lifi-fee-assertions.d.ts",
+    "dist/lifi-swap-assertions.d.ts",
+    "dist/polymarket-clob-client.d.ts",
+    "dist/polymarket-order-assertions.d.ts",
+    "dist/polymarket-order-builder.d.ts",
+    "dist/local-config.d.ts",
+    "dist/mcp-server.d.ts",
+    "dist/stdio-main.d.ts",
+    "dist/tool-definitions.d.ts",
+    "dist/x402-read-source.d.ts",
+    "dist/execution-index.d.ts",
+    "dist/execution-intent.js",
+    "dist/execution-intent.d.ts",
+    "dist/adapter",
+    "dist/adapter-index.js",
+    "dist/adapter-index.d.ts",
+    "dist/adapter-cdp-index.js",
+    "dist/adapter-cdp-index.d.ts",
+    "dist/execution-delegation.js",
+    "dist/execution-delegation.d.ts",
+    "dist/execution-delegation-policy.js",
+    "dist/execution-delegation-policy.d.ts",
+    "dist/execution-delegated-definition.js",
+    "dist/execution-delegated-definition.d.ts",
+    "dist/prepared-artifacts.js",
+    "dist/prepared-artifacts.d.ts",
+    "dist/execution-delegation-admin.js",
+    "dist/execution-delegation-admin.d.ts",
+    "dist/execution-delegation-admin-definition.js",
+    "dist/execution-delegation-admin-definition.d.ts",
+    "dist/boot-redaction.js",
+    "dist/boot-redaction.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "start": "node dist/hosted-main.js",
+    "start:stdio": "node dist/stdio-main.js",
+    "dev:hosted": "tsx watch src/hosted-main.ts",
+    "dev:stdio": "tsx src/stdio-main.ts",
+    "demo:hosted": "tsx scripts/demo-hosted.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test \"test/**/*.test.ts\"",
+    "test:liveness": "node --import tsx --test --test-name-pattern=liveness test/execution-tools.test.ts test/execution-bridge.test.ts test/execution-polymarket.test.ts test/execution-hyperliquid.test.ts",
+    "test:mutation": "node --import tsx test/lifi-fee-mutation-proof.ts && node --import tsx test/lifi-bridge-mutation-proof.ts && node --import tsx test/polymarket-order-mutation-proof.ts && node --import tsx test/hyperliquid-order-mutation-proof.ts",
+    "verify": "npm run typecheck && npm test && npm run build",
+    "prepublishOnly": "npm run verify"
+  },
+  "engines": {
+    "node": "=22.16.0",
+    "npm": ">=10.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "x402",
+    "market-intelligence",
+    "robinhood-chain",
+    "sec-edgar"
+  ],
+  "author": "otto AI",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@nktkas/hyperliquid": "0.29.1",
+    "@polymarket/clob-client-v2": "1.0.0",
+    "@x402/axios": "2.23.0",
+    "@x402/evm": "2.23.0",
+    "axios": "^1.7.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^5.1.0",
+    "express-rate-limit": "^8.2.1",
+    "valibot": "1.2.0",
+    "viem": "2.55.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "overrides": {
+    "@hono/node-server": "2.0.10",
+    "@coinbase/cdp-sdk": {
+      "@x402/evm": "2.23.0",
+      "@x402/core": "2.23.0"
+    }
+  },
+  "exports": {
+    "./execution": {
+      "types": "./dist/execution-index.d.ts",
+      "import": "./dist/execution-index.js"
+    },
+    "./package.json": "./package.json",
+    "./adapter": {
+      "types": "./dist/adapter-index.d.ts",
+      "import": "./dist/adapter-index.js"
+    },
+    "./adapter-cdp": {
+      "types": "./dist/adapter-cdp-index.d.ts",
+      "import": "./dist/adapter-cdp-index.js"
+    }
+  },
+  "optionalDependencies": {
+    "@coinbase/cdp-sdk": "1.54.0"
+  },
+  "publishGate": "UNPUBLISHED (registry E404 as of 2026-08-29). The PR #2001 r1 MED is RESOLVED as of 2026-09-01: @x402/axios+evm are pinned 2.23.0 (>= the ^2.19.0 that @coinbase/cdp-sdk's optional peers want), so the graph now dedupes to a single @x402/core@2.23.0 and `npm ls` reports ZERO invalid/UNMET peers WITHOUT relying on the `overrides` pin \u2014 which npm honors in the root project only and does NOT inherit to consumers. The overrides entry is kept, bumped in lockstep, as belt-and-braces determinism for the Railway (root) install. NOTE (@x402 2.23.0 behavior change): client `spendControls` are now ON BY DEFAULT \u2014 recognized pegged assets only, $1 USD per-payment cap. Every tool price here is $0.001-$0.10, and a $0.10 Base-USDC payment was verified to build a payload on this exact client construction, so there is ~10x headroom; but any FUTURE tool price above $1 will be refused client-side unless `spendControls` is configured on the x402Client in src/x402-read-source.ts. 2.24.0 exists but is inside the harness's rolling 7-day supply-chain cooldown (`--before`), so 2.23.0 is the newest installable stable 2.x."
+}