@coinrithm/mcp-trading 0.1.8 → 0.3.0

package/dist/agent/decision.d.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import { Decision } from "./types.js";
+export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"futures_open">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<["long", "short"]>;
+    leverage: z.ZodNumber;
+    marginMusd: z.ZodNumber;
+    stopLossPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    takeProfitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    symbol: string;
+    side: "long" | "short";
+    leverage: number;
+    marginMusd: number;
+    type: "futures_open";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    symbol: string;
+    side: "long" | "short";
+    leverage: number;
+    marginMusd: number;
+    type: "futures_open";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"futures_close">;
+    positionId: z.ZodNumber;
+    fraction: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    positionId: number;
+    type: "futures_close";
+    fraction?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    positionId: number;
+    type: "futures_close";
+    fraction?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"futures_set_sltp">;
+    positionId: z.ZodNumber;
+    stopLossPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    takeProfitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    positionId: number;
+    type: "futures_set_sltp";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+}, {
+    positionId: number;
+    type: "futures_set_sltp";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"spot_order">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<["buy", "sell"]>;
+    orderType: z.ZodEnum<["market", "limit", "stop"]>;
+    quantity: z.ZodNumber;
+    limitPrice: z.ZodOptional<z.ZodNumber>;
+    stopPrice: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    symbol: string;
+    side: "buy" | "sell";
+    orderType: "limit" | "market" | "stop";
+    quantity: number;
+    type: "spot_order";
+    limitPrice?: number | undefined;
+    stopPrice?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    symbol: string;
+    side: "buy" | "sell";
+    orderType: "limit" | "market" | "stop";
+    quantity: number;
+    type: "spot_order";
+    limitPrice?: number | undefined;
+    stopPrice?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"spot_cancel">;
+    orderId: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    type: "spot_cancel";
+    orderId: number;
+}, {
+    type: "spot_cancel";
+    orderId: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pm_open">;
+    source: z.ZodString;
+    slug: z.ZodString;
+    outcomeExternalMarketId: z.ZodString;
+    stakeMusd: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    stakeMusd: number;
+    type: "pm_open";
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    stakeMusd: number;
+    type: "pm_open";
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>]>;
+export type ParseDecisionResult = {
+    ok: true;
+    decision: Decision;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseDecision(text: string): ParseDecisionResult;

package/dist/agent/decision.js

@@ -0,0 +1,118 @@
+// Parse the model's single text response into a strict, structured Decision.
+// Accepts futures + spot + prediction-market actions. Anything else — invalid
+// JSON, an unknown action type, a free-form endpoint/tool name, extra unknown
+// fields, or a missing required field — fails closed (the runner skips).
+import { z } from "zod";
+const futuresOpen = z
+    .object({
+    type: z.literal("futures_open"),
+    symbol: z.string().min(1),
+    side: z.enum(["long", "short"]),
+    leverage: z.number().positive(),
+    marginMusd: z.number().positive(),
+    stopLossPrice: z.number().nullable().optional(),
+    takeProfitPrice: z.number().nullable().optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+const futuresClose = z
+    .object({
+    type: z.literal("futures_close"),
+    positionId: z.number(),
+    fraction: z.number().positive().max(1).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+const futuresSetSltp = z
+    .object({
+    type: z.literal("futures_set_sltp"),
+    positionId: z.number(),
+    stopLossPrice: z.number().nullable().optional(),
+    takeProfitPrice: z.number().nullable().optional(),
+})
+    .strict();
+const spotOrder = z
+    .object({
+    type: z.literal("spot_order"),
+    symbol: z.string().min(1),
+    side: z.enum(["buy", "sell"]),
+    orderType: z.enum(["market", "limit", "stop"]),
+    quantity: z.number().positive(),
+    limitPrice: z.number().positive().optional(),
+    stopPrice: z.number().positive().optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+const spotCancel = z
+    .object({
+    type: z.literal("spot_cancel"),
+    orderId: z.number(),
+})
+    .strict();
+const pmOpen = z
+    .object({
+    type: z.literal("pm_open"),
+    source: z.string().min(1),
+    slug: z.string().min(1),
+    outcomeExternalMarketId: z.string().min(1),
+    stakeMusd: z.number().positive(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+export const actionSchema = z.discriminatedUnion("type", [
+    futuresOpen,
+    futuresClose,
+    futuresSetSltp,
+    spotOrder,
+    spotCancel,
+    pmOpen,
+]);
+const decisionSchema = z
+    .object({
+    decision: z.enum(["skip", "act"]),
+    confidence: z.number().min(0).max(1).optional(),
+    reason: z.string().optional(),
+    actions: z.array(actionSchema).default([]),
+})
+    .strict();
+// Pull a JSON object out of a model response that may be fenced or wrapped.
+function coerceJson(text) {
+    let s = text.trim();
+    const fence = /^```(?:json)?\s*([\s\S]*?)\s*```$/.exec(s);
+    if (fence)
+        s = fence[1].trim();
+    if (!s.startsWith("{")) {
+        const i = s.indexOf("{");
+        const j = s.lastIndexOf("}");
+        if (i >= 0 && j > i)
+            s = s.slice(i, j + 1);
+    }
+    return JSON.parse(s); // throws on invalid JSON -> caller treats as fail-closed
+}
+export function parseDecision(text) {
+    let obj;
+    try {
+        obj = coerceJson(text);
+    }
+    catch (err) {
+        return { ok: false, error: `model output is not valid JSON: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const res = decisionSchema.safeParse(obj);
+    if (!res.success) {
+        return {
+            ok: false,
+            error: res.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; "),
+        };
+    }
+    const d = res.data;
+    // A "skip" decision ignores any actions; an "act" with no actions is a skip.
+    const actions = d.decision === "act" ? d.actions : [];
+    return {
+        ok: true,
+        decision: { decision: d.decision, confidence: d.confidence, reason: d.reason, actions },
+    };
+}

package/dist/agent/decisionValidator.d.ts

@@ -0,0 +1,16 @@
+import { AgentSpec, Observation, ProposedAction, QuoteEvidence, ValidationResult } from "./types.js";
+export interface DecisionContext {
+    spec: AgentSpec;
+    decisionConfidence?: number;
+    observation: Observation;
+    quote?: QuoteEvidence;
+    writesThisCycle: number;
+    writesToday: number;
+    openCount: number;
+    cashAvailableMusd: number | null;
+    openMarginMusd: number;
+    realizedLossTodayMusd: number;
+    targetedPositionIds: number[];
+    targetedOrderIds: number[];
+}
+export declare function validateAction(action: ProposedAction, ctx: DecisionContext): ValidationResult;

package/dist/agent/decisionValidator.js

@@ -0,0 +1,215 @@
+// The decision gate: re-check EVERY proposed action against the spec's hard caps
+// BEFORE any write. The model only proposes; this disposes. Because the caps
+// come from the spec (not the observation or the model), a prompt-injection in
+// market text cannot widen a limit or force a trade. Covers futures + spot + PM.
+import { ok, fail, actionVenue, spotBuyCost, } from "./types.js";
+const SERVER_MAX_LEVERAGE = 20;
+const PM_MIN_STAKE_MUSD = 10; // server minimum prediction-market stake
+export function validateAction(action, ctx) {
+    const { spec, observation } = ctx;
+    const venue = actionVenue(action);
+    if (!spec.venues.includes(venue)) {
+        return fail("venue_not_allowed", `venue ${venue} not in [${spec.venues.join(", ")}]`);
+    }
+    if (spec.sync.requirePollBeforeWrite && !observation.polledBeforeWrite) {
+        return fail("no_poll_before_write", "must successfully poll /trades before writing");
+    }
+    if (ctx.writesThisCycle >= spec.limits.maxWritesPerCycle) {
+        return fail("write_budget_exceeded", `maxWritesPerCycle ${spec.limits.maxWritesPerCycle} reached`);
+    }
+    if (ctx.writesToday >= spec.limits.maxTradesPerDay) {
+        return fail("daily_trade_cap", `maxTradesPerDay ${spec.limits.maxTradesPerDay} reached`);
+    }
+    // Deny-list: an open on a blocked symbol is rejected up front (deny wins over
+    // the watchlist). PM opens use a market slug, not a coin symbol, so skip them.
+    if (action.type === "futures_open" || action.type === "spot_order") {
+        const blocklist = spec.risk.blocklist;
+        if (Array.isArray(blocklist) && blocklist.length > 0) {
+            const sym = action.symbol.toUpperCase();
+            if (blocklist.some((b) => b.toUpperCase() === sym)) {
+                return fail("blocked_symbol", `${action.symbol} is on the deny-list`);
+            }
+        }
+    }
+    if (action.type === "futures_open") {
+        // Daily realized-loss stop: once today's loss hits the cap, open no new risk.
+        if (spec.limits.maxDailyLossMusd > 0 &&
+            ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+            return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
+        }
+        const entry = observation.watch.find((w) => w.symbol.toUpperCase() === action.symbol.toUpperCase());
+        if (!entry)
+            return fail("unknown_symbol", `${action.symbol} is not on the watchlist`);
+        if (!entry.coinId)
+            return fail("unresolved_symbol", `${action.symbol} did not resolve to a coin`);
+        if (action.leverage > spec.risk.maxLeverage) {
+            return fail("leverage_exceeds_cap", `leverage ${action.leverage} > cap ${spec.risk.maxLeverage}`);
+        }
+        if (action.leverage > SERVER_MAX_LEVERAGE) {
+            return fail("leverage_exceeds_server", `leverage ${action.leverage} > server cap ${SERVER_MAX_LEVERAGE}`);
+        }
+        if (action.marginMusd > spec.risk.perTradeMarginMusd) {
+            return fail("margin_exceeds_cap", `margin ${action.marginMusd} > cap ${spec.risk.perTradeMarginMusd}`);
+        }
+        // Aggregate exposure ceiling (existing open margin + this cycle) — the cap
+        // that perTradeMargin × maxConcurrentPositions would otherwise blow past.
+        if (ctx.openMarginMusd + action.marginMusd >
+            spec.limits.maxOpenMarginMusd) {
+            return fail("open_margin_exceeds_cap", `open margin ${ctx.openMarginMusd} + ${action.marginMusd} > ${spec.limits.maxOpenMarginMusd}`);
+        }
+        if (ctx.openCount >= spec.risk.maxConcurrentPositions) {
+            return fail("max_positions", `already ${ctx.openCount} open >= ${spec.risk.maxConcurrentPositions}`);
+        }
+        if (ctx.cashAvailableMusd != null &&
+            action.marginMusd > ctx.cashAvailableMusd) {
+            return fail("insufficient_balance", `margin ${action.marginMusd} > available ${ctx.cashAvailableMusd}`);
+        }
+        // NOTE: minConfidence keys on the model's SELF-REPORTED confidence — a
+        // cooperation hint, NOT an injection-resistant control. The hard caps above
+        // (which come from the spec, never the observation) are what actually bind.
+        if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+            spec.abstention.minConfidence) {
+            return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
+        }
+        if (spec.risk.requireStopLoss) {
+            const sl = action.stopLossPrice;
+            if (sl == null || !Number.isFinite(sl) || sl <= 0) {
+                return fail("missing_stop_loss", "requireStopLoss is set but no valid (finite, positive) stopLossPrice was proposed");
+            }
+            // Side-aware corridor: a long's stop must be BELOW entry, a short's ABOVE.
+            // A wrong-side "stop" is a dead trigger that never protects.
+            const e = ctx.quote?.entryPrice;
+            if (typeof e === "number" && Number.isFinite(e)) {
+                if (action.side === "long" && sl >= e) {
+                    return fail("stop_loss_wrong_side", `long stop ${sl} must be below entry ${e}`);
+                }
+                if (action.side === "short" && sl <= e) {
+                    return fail("stop_loss_wrong_side", `short stop ${sl} must be above entry ${e}`);
+                }
+            }
+        }
+        if (!ctx.quote)
+            return fail("missing_quote", "no quote evidence was fetched for this open");
+        if (!ctx.quote.eligible) {
+            return fail("quote_ineligible", `quote blocked: ${JSON.stringify(ctx.quote.blockReasons ?? [])}`);
+        }
+        // FAIL-CLOSED: a missing freshness block is treated as not-fresh.
+        if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
+            return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
+        }
+        return ok();
+    }
+    if (action.type === "futures_close" || action.type === "futures_set_sltp") {
+        const pos = observation.openPositions.find((p) => p.id === action.positionId && p.venue === "futures");
+        if (!pos)
+            return fail("unknown_position", `no open futures position ${action.positionId}`);
+        // No double-acting on the same position within one cycle.
+        if (ctx.targetedPositionIds.includes(action.positionId)) {
+            return fail("position_already_targeted", `position ${action.positionId} already acted on this cycle`);
+        }
+        if (action.type === "futures_set_sltp") {
+            const hasTrigger = [action.stopLossPrice, action.takeProfitPrice].some((v) => typeof v === "number" && Number.isFinite(v) && v > 0);
+            if (!hasTrigger) {
+                return fail("sltp_no_op", "futures_set_sltp must set at least one positive stopLossPrice or takeProfitPrice");
+            }
+        }
+        return ok();
+    }
+    if (action.type === "spot_order") {
+        const entry = observation.watch.find((w) => w.symbol.toUpperCase() === action.symbol.toUpperCase());
+        if (!entry)
+            return fail("unknown_symbol", `${action.symbol} is not on the watchlist`);
+        if (!entry.coinId)
+            return fail("unresolved_symbol", `${action.symbol} did not resolve to a coin`);
+        if (action.orderType === "limit" &&
+            !(typeof action.limitPrice === "number" && action.limitPrice > 0)) {
+            return fail("missing_limit_price", "a limit order needs a positive limitPrice");
+        }
+        if (action.orderType === "stop" &&
+            !(typeof action.stopPrice === "number" && action.stopPrice > 0)) {
+            return fail("missing_stop_price", "a stop order needs a positive stopPrice");
+        }
+        // A BUY opens new risk: daily-loss stop, confidence, per-trade notional, cash.
+        if (action.side === "buy") {
+            if (spec.limits.maxDailyLossMusd > 0 &&
+                ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+                return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
+            }
+            if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+                spec.abstention.minConfidence) {
+                return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
+            }
+            // Size the BUY with the SAME helper the runner uses to decrement cash, so
+            // the gate and the running-cash accounting never diverge. FAIL CLOSED: an
+            // unpriced market buy (server quote omits executionPrice/estimatedCostMusd)
+            // yields undefined -> reject. The old `cost != null && ...` guards SKIPPED
+            // both caps in that case (notional + balance), a fail-open we must not keep.
+            const cost = spotBuyCost(action, ctx.quote);
+            if (!(typeof cost === "number" && cost > 0)) {
+                return fail("missing_quote_price", "cannot size spot buy notional without a price");
+            }
+            if (cost > spec.risk.perTradeMarginMusd) {
+                return fail("notional_exceeds_cap", `spot notional ${cost} > per-trade cap ${spec.risk.perTradeMarginMusd}`);
+            }
+            if (ctx.cashAvailableMusd != null && cost > ctx.cashAvailableMusd) {
+                return fail("insufficient_balance", `spot cost ${cost} > available ${ctx.cashAvailableMusd}`);
+            }
+        }
+        if (!ctx.quote)
+            return fail("missing_quote", "no quote evidence was fetched for this spot order");
+        if (!ctx.quote.eligible) {
+            return fail("quote_ineligible", `quote blocked: ${JSON.stringify(ctx.quote.blockReasons ?? [])}`);
+        }
+        if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
+            return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
+        }
+        return ok();
+    }
+    if (action.type === "spot_cancel") {
+        const o = observation.openOrders.find((x) => x.id === action.orderId);
+        if (!o)
+            return fail("unknown_order", `no open spot order ${action.orderId}`);
+        if (ctx.targetedOrderIds.includes(action.orderId)) {
+            return fail("order_already_targeted", `order ${action.orderId} already cancelled this cycle`);
+        }
+        return ok();
+    }
+    if (action.type === "pm_open") {
+        if (spec.limits.maxDailyLossMusd > 0 &&
+            ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+            return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
+        }
+        // The model may only open a market that DISCOVERY surfaced this cycle — no
+        // hallucinated source/slug. (source/slug are lowercased; outcome is exact.)
+        const mkt = observation.pmMarkets.find((m) => m.source === action.source.toLowerCase() &&
+            m.slug === action.slug.toLowerCase() &&
+            m.outcomeExternalMarketId === action.outcomeExternalMarketId);
+        if (!mkt) {
+            return fail("pm_market_not_discovered", `${action.source}/${action.slug} is not in the discovered PM markets`);
+        }
+        if (action.stakeMusd < PM_MIN_STAKE_MUSD) {
+            return fail("pm_stake_below_min", `stake ${action.stakeMusd} < $${PM_MIN_STAKE_MUSD} minimum`);
+        }
+        if (action.stakeMusd > spec.risk.perTradeMarginMusd) {
+            return fail("pm_stake_exceeds_cap", `stake ${action.stakeMusd} > per-trade cap ${spec.risk.perTradeMarginMusd}`);
+        }
+        if (ctx.cashAvailableMusd != null &&
+            action.stakeMusd > ctx.cashAvailableMusd) {
+            return fail("insufficient_balance", `stake ${action.stakeMusd} > available ${ctx.cashAvailableMusd}`);
+        }
+        if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+            spec.abstention.minConfidence) {
+            return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
+        }
+        if (!ctx.quote)
+            return fail("missing_quote", "no quote evidence was fetched for this PM open");
+        if (!ctx.quote.eligible) {
+            return fail("quote_ineligible", `quote blocked: ${JSON.stringify(ctx.quote.blockReasons ?? [])}`);
+        }
+        if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
+            return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
+        }
+        return ok();
+    }
+    return fail("unknown_action", "unsupported action type");
+}

package/dist/agent/engine.d.ts

@@ -0,0 +1,10 @@
+export { runCycle, type RunnerDeps } from "./runner.js";
+export { selectProvider, type ProviderEnv, type Provider } from "./providers.js";
+export { CoinRithmClient } from "./client.js";
+export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
+export { resolveAgent } from "./resolve.js";
+export { validateSkill, type SkillValidationMode } from "./skillValidator.js";
+export { newState, rollDay } from "./state.js";
+export { makeRunId } from "./runEvidence.js";
+export { parseCadenceMs } from "./util.js";
+export type { AgentSpec, RunState, CycleResult, PlannedAction, Venue, ProviderName, ModelConfig, } from "./types.js";

package/dist/agent/engine.js

@@ -0,0 +1,16 @@
+// Public engine surface for an external scheduler (the hosted "free run").
+// The runner is storage-agnostic: runCycle takes { spec, mergedProse, state } as
+// plain objects and saveState(undefined) no-ops, so a scheduler can load state
+// from a DB, run one cycle, and persist the mutated state itself — no file I/O.
+//
+// This barrel is the ONE import a host scheduler needs; it re-exports only the
+// stable engine pieces, never the CLI.
+export { runCycle } from "./runner.js";
+export { selectProvider } from "./providers.js";
+export { CoinRithmClient } from "./client.js";
+export { loadAgent, buildSpec } from "./skill.js";
+export { resolveAgent } from "./resolve.js";
+export { validateSkill } from "./skillValidator.js";
+export { newState, rollDay } from "./state.js";
+export { makeRunId } from "./runEvidence.js";
+export { parseCadenceMs } from "./util.js";

package/dist/agent/extract.d.ts

@@ -0,0 +1,4 @@
+export declare const asObj: (v: unknown) => Record<string, unknown>;
+export declare const asArr: (v: unknown) => unknown[];
+export declare const asNum: (v: unknown) => number | undefined;
+export declare const asStr: (v: unknown) => string | undefined;

package/dist/agent/extract.js

@@ -0,0 +1,5 @@
+// Defensive extractors for untyped API JSON.
+export const asObj = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+export const asArr = (v) => (Array.isArray(v) ? v : []);
+export const asNum = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+export const asStr = (v) => typeof v === "string" ? v : undefined;

package/dist/agent/frontmatter.d.ts

@@ -0,0 +1,5 @@
+export interface Frontmatter {
+    data: Record<string, unknown>;
+    body: string;
+}
+export declare function parseFrontmatter(text: string): Frontmatter;

package/dist/agent/frontmatter.js

@@ -0,0 +1,19 @@
+import { parse as parseYaml } from "yaml";
+export function parseFrontmatter(text) {
+    const src = text.replace(/\r\n/g, "\n");
+    const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(src);
+    if (!m) {
+        throw new Error("skill file has no YAML frontmatter (expected a `---` block at the top)");
+    }
+    let data;
+    try {
+        data = parseYaml(m[1]);
+    }
+    catch (err) {
+        throw new Error(`skill frontmatter is not valid YAML: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (data == null || typeof data !== "object" || Array.isArray(data)) {
+        throw new Error("skill frontmatter must be a YAML mapping (key: value pairs)");
+    }
+    return { data: data, body: (m[2] ?? "").trim() };
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/agent/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// coinrithm-agent CLI entrypoint.
+import { main } from "./cli.js";
+main(process.argv.slice(2))
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    // eslint-disable-next-line no-console
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/agent/indicators.d.ts

@@ -0,0 +1,44 @@
+export interface Candle {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+export declare function sma(values: number[], period: number): number | null;
+export declare function ema(values: number[], period: number): number | null;
+export declare function rsi(closes: number[], period?: number): number | null;
+export declare function atr(candles: Candle[], period?: number): number | null;
+export interface Bollinger {
+    upper: number;
+    mid: number;
+    lower: number;
+}
+export declare function bollinger(closes: number[], period?: number, mult?: number): Bollinger | null;
+export interface HighLow {
+    high: number;
+    low: number;
+}
+export declare function recentHighLow(candles: Candle[], lookback: number): HighLow | null;
+export interface IndicatorSet {
+    asOfClose: number;
+    rsi14: number | null;
+    ema20: number | null;
+    ema50: number | null;
+    atr14: number | null;
+    bollinger: Bollinger | null;
+    recent20: HighLow | null;
+    aboveEma20: boolean | null;
+    ema20AboveEma50: boolean | null;
+    brokeRecentHigh: boolean | null;
+    brokeRecentLow: boolean | null;
+}
+export interface IndicatorOpts {
+    rsiPeriod?: number;
+    emaFast?: number;
+    emaSlow?: number;
+    atrPeriod?: number;
+    bbPeriod?: number;
+    breakoutLookback?: number;
+}
+export declare function computeIndicators(candles: Candle[], opts?: IndicatorOpts): IndicatorSet | null;