@coinrithm/mcp-trading 0.7.14 → 0.7.16

package/dist/agent/skillValidator.js

@@ -1,5 +1,7 @@
 import { fail, VENUES, PROVIDERS, SPEC_VERSION, OBJECTIVE_PRIMARIES, ALLOWED_CAPABILITIES, } from "./types.js";
+import { universeIssues } from "./universe.js";
 import { parseCadenceMs, scanForSecrets } from "./util.js";
+import { signalIssues } from "./signals.js";
 import { entryPredicateIssues } from "./entryPredicates.js";
 const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isPosNum = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
@@ -88,6 +90,12 @@ export function validateSkill(parsed, mode = "self-host") {
                 add("skill_venue_unknown", `unknown venue "${String(v)}" (allowed: ${VENUES.join(", ")})`);
         }
     }
+    // Signal thresholds and data diet (optional).
+    for (const [code, reason] of signalIssues(raw.signals, raw.data))
+        add(code, reason);
+    // Market boundaries (optional).
+    for (const [code, reason] of universeIssues(raw.universe))
+        add(code, reason);
     // Risk — always required
     if (!isObj(raw.risk)) {
         add("skill_risk", "risk block is required (the caps the agent runs under)");
@@ -115,6 +123,31 @@ export function validateSkill(parsed, mode = "self-host") {
             if (typeof f !== "number" || !Number.isFinite(f) || f < 0 || f > 100)
                 add("skill_risk_pm_entry_floor", "risk.pmMinEntryProbabilityPct must be a number between 0 and 100 (points; omit for no floor)");
         }
+        if (r.pmMinEdgeGapPct !== undefined) {
+            const g = r.pmMinEdgeGapPct;
+            if (typeof g !== "number" || !Number.isFinite(g) || g < 0 || g > 100)
+                add("skill_risk_pm_edge_gap", "risk.pmMinEdgeGapPct must be a number between 0 and 100 (% of the gap to 100; omit for the global minimum edge only)");
+        }
+        if (r.pmMaxEdgePoints !== undefined) {
+            const m = r.pmMaxEdgePoints;
+            if (typeof m !== "number" || !Number.isFinite(m) || m < 0 || m > 100)
+                add("skill_risk_pm_max_edge", "risk.pmMaxEdgePoints must be a number between 0 and 100 (points over cost; omit for no cap)");
+        }
+        if (r.pmMaxOpenPerEvent !== undefined) {
+            const n = r.pmMaxOpenPerEvent;
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > 50)
+                add("skill_risk_pm_per_event", "risk.pmMaxOpenPerEvent must be a whole number between 1 and 50 (omit for no per-event cap)");
+        }
+        if (r.pmMaxOpenPerCoinHorizon !== undefined) {
+            const n = r.pmMaxOpenPerCoinHorizon;
+            if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > 50)
+                add("skill_risk_pm_coin_horizon", "risk.pmMaxOpenPerCoinHorizon must be a whole number between 1 and 50 (omit for no per-coin-horizon cap)");
+        }
+        if (r.pmMinMinutesToClose !== undefined) {
+            const m = r.pmMinMinutesToClose;
+            if (typeof m !== "number" || !Number.isFinite(m) || m < 0 || m > 10_080)
+                add("skill_risk_pm_close_cutoff", "risk.pmMinMinutesToClose must be a number of minutes between 0 and 10080 (omit for no cutoff)");
+        }
         // Fail-closed on the side restriction: a typo ("shorts_only") must never
         // silently mean "unrestricted" — that is exactly how a prose-only
         // constraint failed live on 2026-08-24.

package/dist/agent/strictLint.js

@@ -30,8 +30,29 @@ const ALLOWED_KEYS = {
         // it) but was missing here, so any bundle actually SETTING it got an
         // unknown_key lint — the knob existed and was unreachable (audit rank 10).
         "triggerPolicy",
+        "signals",
+        "data",
+        "universe",
     ],
     trigger: ["cadence", "timezone", "events"],
+    signals: [
+        "rsiOversold",
+        "rsiOverbought",
+        "strongMovePct",
+        "leanMovePct",
+        "minStrength",
+    ],
+    data: ["indicatorRange"],
+    universe: [
+        "rank",
+        "minVolume24hUsd",
+        "excludeStablecoins",
+        "includeSectors",
+        "excludeSectors",
+        "sort",
+        "resolveTop",
+        "scanLimit",
+    ],
     triggerPolicy: [
         "mode",
         "skipLlmWhenNoTrigger",
@@ -51,6 +72,11 @@ const ALLOWED_KEYS = {
         "direction",
         "entryPredicates",
         "pmMinEntryProbabilityPct",
+        "pmMinEdgeGapPct",
+        "pmMaxEdgePoints",
+        "pmMaxOpenPerEvent",
+        "pmMaxOpenPerCoinHorizon",
+        "pmMinMinutesToClose",
     ],
     sizing: null,
     capitalSizing: [
@@ -141,6 +167,9 @@ export function strictLint(raw) {
         "sync",
         "killSwitch",
         "objective",
+        "signals",
+        "data",
+        "universe",
     ]) {
         if (isObj(raw[block]))
             lintKeys(block, raw[block], issues);

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];

package/dist/agent/types.d.ts

@@ -1,5 +1,7 @@
+import type { FuturesEntryEligibility } from "./futuresEligibility.js";
 import { IndicatorSet } from "./indicators.js";
 import type { DecisionInputRecord } from "./decisionReceipt.js";
+import type { DecideRouteAttempt } from "./providers.js";
 export declare const SPEC_VERSION = "coinrithm.agent.v1";
 export type Venue = "spot" | "futures" | "pm";
 export declare const VENUES: readonly Venue[];
@@ -35,6 +37,11 @@ export interface RiskConfig {
     blocklist?: string[];
     direction?: "long_only" | "short_only";
     pmMinEntryProbabilityPct?: number;
+    pmMinEdgeGapPct?: number;
+    pmMaxEdgePoints?: number;
+    pmMaxOpenPerEvent?: number;
+    pmMaxOpenPerCoinHorizon?: number;
+    pmMinMinutesToClose?: number;
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -97,7 +104,7 @@ export interface ObjectiveConfig {
     secondary: string[];
     horizon?: string;
 }
-export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan"];
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan", "whale_context"];
 export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
 export interface AgentSpec {
     name: string;
@@ -115,6 +122,25 @@ export interface AgentSpec {
     objective?: ObjectiveConfig;
     capabilities: Capability[];
     triggerPolicy?: TriggerPolicy;
+    signals?: Partial<import("./signals.js").SignalThresholds>;
+    data?: {
+        indicatorRange?: import("./signals.js").IndicatorRange;
+    };
+    universe?: UniverseConfig;
+}
+/** Declared market boundaries; see universe.ts for semantics and defaults. */
+export interface UniverseConfig {
+    rank?: {
+        min?: number;
+        max?: number;
+    };
+    minVolume24hUsd?: number;
+    excludeStablecoins?: boolean;
+    includeSectors?: string[];
+    excludeSectors?: string[];
+    sort?: "gainers_24h" | "losers_24h" | "abs_change_24h" | "abs_change_1h" | "volume_24h" | "rank";
+    resolveTop?: number;
+    scanLimit?: number;
 }
 export interface ParsedSkill {
     spec: AgentSpec;
@@ -135,8 +161,8 @@ export interface Freshness {
     basis?: string;
 }
 export interface IndicatorContext {
-    range: "1D";
-    nominalIntervalSeconds: 300;
+    range: import("./signals.js").IndicatorRange;
+    nominalIntervalSeconds: number;
     barCount: number;
     timestampedBarCount: number;
     checkedIntervalCount: number;
@@ -149,6 +175,105 @@ export interface IndicatorContext {
         intervalStatus: "regular" | "irregular" | "unknown";
     };
 }
+export interface OpenInterestContext {
+    totalUsd: number;
+    venues: string[];
+    change1hPct: number | null;
+    change1hVenues: string[];
+    change24hPct: number | null;
+    change24hVenues: string[];
+    asOf: string;
+    stale: boolean;
+}
+export interface DatedValue {
+    value: number;
+    asOf: string;
+    stale: boolean;
+}
+export interface PositioningContext {
+    venue: string;
+    symbol: string;
+    longShortAccountRatio?: DatedValue;
+    longAccountPct?: DatedValue;
+    topTraderPositionRatio?: DatedValue;
+    takerBuySellRatio?: DatedValue;
+}
+export interface LiquidationWindow {
+    longLiquidatedUsdt: number;
+    shortLiquidatedUsdt: number;
+    events: number;
+    capturedPct: number;
+}
+export interface LiquidationContext {
+    venue: string;
+    instId: string;
+    last1h: LiquidationWindow;
+    last24h: LiquidationWindow;
+    lastEventAt: string | null;
+}
+export interface MacroQuote {
+    symbol: string;
+    label: string;
+    kind: string;
+    price: number;
+    change24hPct: number | null;
+    asOf: string;
+    stale: boolean;
+}
+export interface MacroContext {
+    note: string;
+    quotes: MacroQuote[];
+}
+export interface ChainTvlContext {
+    chain: string;
+    tvlUsd: number;
+    publishedAt: string | null;
+    fetchedAt: string | null;
+    sourceObservedAt: null;
+    stale: boolean;
+    dayAt: string | null;
+    change1dPct: number | null;
+    change7dPct: number | null;
+}
+export interface StablecoinSupplyContext {
+    totalUsd: number;
+    dayAt: string;
+    change1dPct: number | null;
+    change7dPct: number | null;
+    stale: boolean;
+}
+export interface DepthSideContext {
+    usd: number;
+    reachPct: number;
+    levels: number;
+    complete: boolean;
+}
+export interface DepthContext {
+    venue: string;
+    bid: DepthSideContext | null;
+    ask: DepthSideContext | null;
+    asOf: string;
+    stale: boolean;
+}
+export interface FundingVenueRate {
+    role: "settlement_reference" | "context_only";
+    venue: string;
+    symbol: string;
+    source: "paper_futures_reference" | "hyperliquid_predicted_fundings";
+    rateFraction: number;
+    intervalHours: number | null;
+    hourlyEquivalentFraction: number | null;
+    nextFundingTime: string | null;
+    fetchedAt: string;
+    sourceAt: null;
+    ageSeconds: number;
+    stale: boolean;
+    freshnessBasis: "collection_time";
+}
+export interface FundingByVenueContext {
+    rates: FundingVenueRate[];
+    sameTime: false;
+}
 export interface WatchEntry {
     symbol: string;
     coinId: string | null;
@@ -158,12 +283,23 @@ export interface WatchEntry {
     change24h?: number;
     change7d?: number;
     sentimentBullishPct?: number;
+    sentimentTotalVotes?: number;
+    sentimentDayUtc?: string;
+    sentimentUpdatedAt?: string;
     freshness?: Freshness;
     indicators?: IndicatorSet;
     indicatorContext?: IndicatorContext;
     discovered?: boolean;
+    withinBoundaries?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
+    openInterest?: OpenInterestContext;
+    positioning?: PositioningContext;
+    liquidations?: LiquidationContext;
+    chainTvl?: ChainTvlContext;
+    depth?: DepthContext;
+    fundingByVenue?: FundingByVenueContext;
+    futuresEntryEligibility?: FuturesEntryEligibility;
 }
 export interface CoinFundamentals {
     categories?: string[];
@@ -222,6 +358,8 @@ export interface PmPosition {
     entryProbability?: number;
     currentProbability?: number;
     openedAt?: string;
+    coins?: string[];
+    endDate?: string;
     thesis?: ThesisView;
 }
 export interface PmResolution {
@@ -245,8 +383,45 @@ export interface PmMarket {
     volumeUsd?: number;
     endDate?: string;
     liquidityUsd?: number;
+    coins?: string[];
     quality?: PmQuality;
     decisionSupport?: PmDecisionSupport;
+    consensus?: PmConsensus | null;
+    rules?: PmSettlementRule | null;
+    outcomeRule?: PmOutcomeRule;
+}
+export interface PmCalibration {
+    settled: number;
+    brierAgent: number | null;
+    brierMarket: number | null;
+    meanForecastPct: number | null;
+    winRatePct: number | null;
+    bands: Array<{
+        fromPct: number;
+        toPct: number;
+        n: number;
+        meanForecastPct: number;
+        winRatePct: number;
+    }>;
+}
+export interface PmSettlementRule {
+    published: boolean;
+    text?: string;
+    sources?: string[];
+    scope?: "per_outcome";
+}
+export type PmOutcomeRule = {
+    primary: string;
+    secondary?: string;
+} | {
+    unknown: "source_rules_unavailable" | "market_not_found" | "rule_missing" | "conflicting_duplicates" | "unreadable";
+};
+export interface PmConsensus {
+    prob: number;
+    venues: number;
+    spreadPts: number;
+    kind: "binary" | "leader";
+    outcome: string | null;
 }
 export interface PmQuality {
     decisionEligible?: boolean;
@@ -281,6 +456,80 @@ export interface NewsItem {
     ageHours?: number;
     publishedAt?: string;
     coins?: string[];
+    url?: string;
+    category?: string;
+}
+export type WhaleContextStatus = "available" | "partial" | "unavailable";
+export type WhaleContextFailure = "timeout" | "network_error" | "http_error" | "invalid_payload";
+export interface WhaleTradeContext {
+    source: string;
+    eventSlug: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    sourceMarketRef?: string;
+    valueBasis?: string;
+    evidenceType?: string;
+    evidenceRef?: string;
+    nativeValue?: number;
+    nativeCurrency?: string;
+    availability?: "live" | "delayed" | "unavailable";
+    tradedAt?: string;
+    observedAt?: string;
+    latencySeconds?: number;
+    walletAddress?: string;
+}
+export interface WhaleWalletFillContext {
+    eventSlug?: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side?: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    evidenceType?: string;
+    tradedAt?: string;
+    sourceMarketRef?: string;
+}
+export interface WhaleWalletContext {
+    source: string;
+    address: string;
+    asOf?: string;
+    summary30d?: {
+        basis?: string;
+        windowStart?: string;
+        tradeCount?: number;
+        notionalUsd?: number;
+        buyNotionalUsd?: number;
+        sellNotionalUsd?: number;
+    };
+    rollup?: {
+        available?: boolean;
+        coveredDays?: number;
+        from?: string;
+        to?: string;
+        computedAt?: string;
+    };
+    daily: Array<{
+        day?: string;
+        tradeCount?: number;
+        buyCount?: number;
+        sellCount?: number;
+        notionalUsd?: number;
+    }>;
+    recentFills: WhaleWalletFillContext[];
+}
+export interface WhaleContext {
+    status: WhaleContextStatus;
+    fetchedAt: string;
+    coverage: "relevant_events" | "no_relevant_events";
+    trades: WhaleTradeContext[];
+    wallets: WhaleWalletContext[];
+    omitted: number;
+    reason?: WhaleContextFailure;
 }
 export interface Observation {
     asOf: string;
@@ -293,16 +542,21 @@ export interface Observation {
     pmPositions: PmPosition[];
     pmResolutions: PmResolution[];
     pmMarkets: PmMarket[];
+    pmCalibration?: PmCalibration;
     watch: WatchEntry[];
     setups: SetupSignal[];
     marketMood?: {
         fearGreed: number;
         label: string;
+        fetchedAt?: string;
     };
+    macro?: MacroContext;
+    stablecoinSupply?: StablecoinSupplyContext;
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
     news?: NewsItem[];
+    whaleContext?: WhaleContext;
     universeMovers?: Array<{
         symbol: string;
         name?: string;
@@ -522,19 +776,18 @@ export interface CycleResult {
     tokensIn?: number;
     tokensOut?: number;
     estimatedCostUsd?: number;
+    providerUsage?: {
+        promptTokens: number;
+        completionTokens: number;
+        cacheReadTokens?: number;
+        cacheWriteTokens?: number;
+        cacheWrite5mTokens?: number;
+        cacheWrite1hTokens?: number;
+    };
     effectiveProvider?: string;
     effectiveModel?: string;
     routeReason?: string;
-    routeAttempts?: Array<{
-        provider: string;
-        model: string;
-        outcome: "success" | "failed" | "deferred";
-        failureClass?: "capacity" | "permanent" | "transient" | "malformed";
-        status?: number;
-        retryAfterMs?: number;
-        latencyMs: number;
-        error?: string;
-    }>;
+    routeAttempts?: DecideRouteAttempt[];
     decisionType?: "act" | "skip" | "gate_skip" | "model_error";
     writeAttempted?: number;
     writeAccepted?: number;

package/dist/agent/types.js

@@ -50,6 +50,9 @@ export const OBJECTIVE_PRIMARIES = [
 // slice. `websearch` = external lookups (an injection surface + a cost — it can
 // inform reasoning but NEVER widen a cap, since caps live in the runner);
 // `indicators` = runner-computed RSI/MACD/etc. fed into the observation.
+// `whale_context` reads bounded public prediction-market whale context only
+// after the deterministic gate fires, and only when PM is in the venue scope.
+// It never widens the candidate set or acts as a trading signal by itself.
 // `universe_scan` (2026-08-18, direct user request): each cycle the runner
 // pulls the top 24h movers across CoinRithm's tracked coin universe, resolves
 // the top few into FULL watch entries (price, sentiment, indicators when that
@@ -64,6 +67,7 @@ export const ALLOWED_CAPABILITIES = [
     "indicators",
     "news",
     "universe_scan",
+    "whale_context",
 ];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({

package/dist/agent/universe.d.ts

@@ -0,0 +1,78 @@
+import type { UniverseConfig } from "./types.js";
+export declare const UNIVERSE_SORTS: readonly ["gainers_24h", "losers_24h", "abs_change_24h", "abs_change_1h", "volume_24h", "rank"];
+export type UniverseSort = (typeof UNIVERSE_SORTS)[number];
+export declare const UNIVERSE_DEFAULTS: {
+    rankMin: number;
+    rankMax: number;
+    minVolume24hUsd: number;
+    sort: UniverseSort;
+    resolveTop: number;
+    scanLimit: number;
+};
+export declare const UNIVERSE_MAX_RESOLVE_TOP = 10;
+export declare const UNIVERSE_MAX_SCAN_LIMIT = 50;
+/** True when the agent discovers candidates beyond its watchlist. */
+export declare function scansUniverse(spec: {
+    capabilities: readonly string[];
+    universe?: UniverseConfig;
+}): boolean;
+export interface UniverseQuery {
+    rankMin: number;
+    rankMax: number;
+    minVolume24hUsd: number;
+    excludeStablecoins: boolean;
+    includeSectors: string[];
+    excludeSectors: string[];
+    sort: UniverseSort;
+    limit: number;
+}
+/** The screener query a validated universe block asks for. */
+export declare function universeQuery(u: UniverseConfig): UniverseQuery;
+/** How many screener rows become full watch entries this cycle. */
+export declare function universeResolveTop(u: UniverseConfig): number;
+/** Wire form: csv sectors, string numbers; empty filters are omitted. With
+ * `ucids`, the same boundaries are applied to just those coins (membership). */
+export declare function universeQueryParams(q: UniverseQuery, ucids?: readonly string[]): Record<string, string | number>;
+export interface UniverseRow {
+    symbol: string;
+    coinId?: string;
+    name?: string;
+    slug?: string;
+    marketCapRank?: number;
+    priceUsd?: number;
+    change1h?: number;
+    change24h?: number;
+    change7d?: number;
+    volume24hUsd?: number;
+    sectors?: string[];
+}
+/** Keep malformed evidence unknown; dropping bad elements can widen a screen. */
+export declare function universeSectorsOf(raw: unknown): string[] | undefined;
+/**
+ * Defence in depth on server rows (never widen): a row is kept only when its
+ * own fields PROVE it is inside every enabled boundary. The rank band is
+ * always enabled, so a row without a rank is dropped; a volume floor needs a
+ * volume; any sector rule (stablecoins out, sectors out, sectors in) needs the
+ * row's sector list. Missing or malformed evidence drops the row (root review
+ * 2026-10-07: unverifiable is not inside).
+ */
+export declare function filterUniverseRows(rows: UniverseRow[], q: UniverseQuery): UniverseRow[];
+/**
+ * Entry eligibility under declared boundaries (root review 2026-10-07): with a
+ * `universe` block, a NEW position may only be opened on a coin proven inside
+ * the boundaries this cycle: a discovered row, or a watchlist coin the
+ * screener confirmed (`withinBoundaries: true`). Anything else (outside, or
+ * unverifiable because the check failed) stays visible as context and can
+ * still be closed or sold, but not entered. Returns the rejection reason, or
+ * null when the entry is allowed. No universe block = no extra rule.
+ */
+export declare function universeEntryBlock(spec: {
+    universe?: UniverseConfig;
+}, entry: {
+    discovered?: boolean;
+    withinBoundaries?: boolean;
+}): string | null;
+/** Validation issues for a raw `universe` block ([] when valid or absent). */
+export declare function universeIssues(raw: unknown): Array<[string, string]>;
+/** One line for the prompt: the boundaries in plain words. */
+export declare function describeUniverse(u: UniverseConfig): string;