@coinrithm/mcp-trading 0.7.7 → 0.7.8

package/dist/agent/scorecard.js

@@ -54,8 +54,14 @@ function normalCdf(z) {
     return z >= 0 ? 1 - p : p;
 }
 // Max peak-to-trough drawdown (mUSD, >= 0) on a cumulative series.
+//
+// The peak seeds at 0, the curve's implicit origin (cumulative realized PnL
+// starts at zero before the first trade). Seeding at -Infinity made the first
+// point its own peak, so a record opening with losses under-reported: [-500,
+// +500, -300] gave 300 instead of 500 and a monotone-losing record gave 0
+// (2026-09-01 rigor review).
 function maxDrawdown(cumulative) {
-    let peak = -Infinity;
+    let peak = 0;
     let maxDd = 0;
     for (const c of cumulative) {
         if (!Number.isFinite(c))

package/dist/agent/skill.js

@@ -63,6 +63,20 @@ function buildModel(raw) {
         baseUrl: typeof m.baseUrl === "string" ? m.baseUrl : undefined,
     };
 }
+// No implicit opt-in and no invented risk percentages. Invalid supplied values
+// remain visibly invalid until validateSkill rejects the raw configuration.
+function buildCapitalSizing(raw) {
+    const policy = obj(raw);
+    return {
+        version: policy.version,
+        futuresRiskPct: num(policy.futuresRiskPct, Number.NaN),
+        pmMaxLossPct: num(policy.pmMaxLossPct, Number.NaN),
+        perTicketCapitalPct: num(policy.perTicketCapitalPct, Number.NaN),
+        totalCapitalPct: num(policy.totalCapitalPct, Number.NaN),
+        cashReservePct: num(policy.cashReservePct, Number.NaN),
+        minRewardRisk: num(policy.minRewardRisk, Number.NaN),
+    };
+}
 // Coerce raw frontmatter into a best-effort AgentSpec. This NEVER throws on bad
 // values — it fills in what it can and lets validateSkill report problems
 // against the raw frontmatter. The runner only proceeds when validation passes.
@@ -85,6 +99,9 @@ export function buildSpec(raw) {
         },
         model: buildModel(raw.model),
         venues,
+        ...(raw.capitalSizing !== undefined
+            ? { capitalSizing: buildCapitalSizing(raw.capitalSizing) }
+            : {}),
         risk: {
             maxLeverage: num(risk.maxLeverage, 1),
             perTradeMarginMusd: num(risk.perTradeMarginMusd, 0),

package/dist/agent/skillValidator.d.ts

@@ -4,4 +4,5 @@ export interface SkillValidation {
     valid: boolean;
     issues: ValidationResult[];
 }
+export declare function validateCapitalSizingPolicy(value: unknown): ValidationResult[];
 export declare function validateSkill(parsed: ParsedSkill, mode?: SkillValidationMode): SkillValidation;

package/dist/agent/skillValidator.js

@@ -4,6 +4,58 @@ const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 const isPosNum = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
 // maxTradesPerDay accepts 0 as the explicit "unlimited daily trades" sentinel.
 const isNonNegNum = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+// Shared by skill loading and the runtime: persisted specs can bypass the
+// loader, so a present malformed policy must never become permissive NaN math.
+export function validateCapitalSizingPolicy(value) {
+    const issues = [];
+    const add = (code, reason) => issues.push(fail(code, reason));
+    const p = value;
+    if (!isObj(p)) {
+        add("skill_capital_sizing", "capitalSizing must be an object");
+        return issues;
+    }
+    const percentKeys = [
+        "futuresRiskPct",
+        "pmMaxLossPct",
+        "perTicketCapitalPct",
+        "totalCapitalPct",
+    ];
+    const allowedKeys = new Set([
+        "version",
+        ...percentKeys,
+        "cashReservePct",
+        "minRewardRisk",
+    ]);
+    for (const key of Object.keys(p)) {
+        if (!allowedKeys.has(key))
+            add("skill_capital_sizing_unknown_key", `unknown capitalSizing key "${key}"`);
+    }
+    if (p.version !== "equity_fraction_v1") {
+        add("skill_capital_sizing_version", 'capitalSizing.version must be "equity_fraction_v1"');
+    }
+    for (const key of percentKeys) {
+        if (!isPosNum(p[key]) || p[key] > 100) {
+            add("skill_capital_sizing_percent", `capitalSizing.${key} must be a finite number in (0, 100]`);
+        }
+    }
+    if (!isNonNegNum(p.cashReservePct) || p.cashReservePct >= 100) {
+        add("skill_capital_sizing_reserve", "capitalSizing.cashReservePct must be a finite number in [0, 100)");
+    }
+    if (!isPosNum(p.minRewardRisk) || p.minRewardRisk < 1) {
+        add("skill_capital_sizing_reward_risk", "capitalSizing.minRewardRisk must be a finite number >= 1");
+    }
+    if (isPosNum(p.perTicketCapitalPct) &&
+        isPosNum(p.totalCapitalPct) &&
+        p.perTicketCapitalPct > p.totalCapitalPct) {
+        add("skill_capital_sizing_ticket_cap", "capitalSizing.perTicketCapitalPct cannot exceed totalCapitalPct");
+    }
+    if (isPosNum(p.totalCapitalPct) &&
+        isNonNegNum(p.cashReservePct) &&
+        p.totalCapitalPct + p.cashReservePct > 100) {
+        add("skill_capital_sizing_total_reserve", "capitalSizing.totalCapitalPct + cashReservePct cannot exceed 100");
+    }
+    return issues;
+}
 export function validateSkill(parsed, mode = "self-host") {
     const raw = parsed.raw;
     const issues = [];
@@ -61,6 +113,10 @@ export function validateSkill(parsed, mode = "self-host") {
             r.direction !== "short_only")
             add("skill_risk_direction", 'risk.direction must be "long_only" or "short_only" (omit for both)');
     }
+    // Opt-in capital sizing is strict in BOTH hosting modes. The older `sizing`
+    // prose block remains soft guidance and never silently activates this policy.
+    if (raw.capitalSizing !== undefined)
+        issues.push(...validateCapitalSizingPolicy(raw.capitalSizing));
     // Model
     if (raw.model === undefined) {
         if (mode === "self-host")

package/dist/agent/state.js

@@ -11,6 +11,7 @@ export function newState(runId) {
         runId,
         cyclesRun: 0,
         writesToday: 0,
+        riskIncreasesToday: 0,
         realizedPnlMusd: 0,
         peakRealizedMusd: 0,
         consecutiveRejectCycles: 0,
@@ -41,6 +42,10 @@ export function loadState(file, runId) {
         return rollDay({
             ...base,
             ...parsed,
+            // Pre-field state counted every write. Conservatively carry that count
+            // into the entry budget until the next UTC rollover rather than silently
+            // granting additional entries on deployment.
+            riskIncreasesToday: parsed.riskIncreasesToday ?? parsed.writesToday ?? 0,
             seen: Array.isArray(parsed.seen) ? parsed.seen : [],
             intentSeq: parsed.intentSeq &&
                 typeof parsed.intentSeq === "object" &&
@@ -62,6 +67,7 @@ export function rollDay(state) {
     if (state.dayKey !== today) {
         state.dayKey = today;
         state.writesToday = 0;
+        state.riskIncreasesToday = 0;
         state.realizedPnlTodayMusd = 0;
     }
     return state;

package/dist/agent/strictLint.js

@@ -17,6 +17,7 @@ const ALLOWED_KEYS = {
         "venues",
         "risk",
         "sizing",
+        "capitalSizing",
         "limits",
         "abstention",
         "sync",
@@ -50,6 +51,15 @@ const ALLOWED_KEYS = {
         "direction",
     ],
     sizing: null,
+    capitalSizing: [
+        "version",
+        "futuresRiskPct",
+        "pmMaxLossPct",
+        "perTicketCapitalPct",
+        "totalCapitalPct",
+        "cashReservePct",
+        "minRewardRisk",
+    ],
     limits: [
         "maxTradesPerDay",
         "maxWritesPerCycle",
@@ -123,6 +133,7 @@ export function strictLint(raw) {
         "triggerPolicy",
         "model",
         "risk",
+        "capitalSizing",
         "limits",
         "abstention",
         "sync",
@@ -133,6 +144,14 @@ export function strictLint(raw) {
             lintKeys(block, raw[block], issues);
     }
     // Enum checks.
+    const capitalSizing = raw.capitalSizing;
+    if (isObj(capitalSizing) && capitalSizing.version !== "equity_fraction_v1") {
+        issues.push({
+            code: "bad_enum",
+            path: "capitalSizing.version",
+            message: 'capitalSizing.version must be "equity_fraction_v1"',
+        });
+    }
     const model = raw.model;
     if (isObj(model) &&
         typeof model.provider === "string" &&

package/dist/agent/thesis.d.ts

@@ -0,0 +1,40 @@
+import { Observation, OpenPosition, PmPosition, PositionThesis, RunState, Thesis, ThesisInvalidation, ThesisView, Venue } from "./types.js";
+export declare const THESIS_MIN_HOLD_MINUTES = 60;
+export declare const THESIS_MAX_HOLD_MINUTES: number;
+export declare const THESIS_SUMMARY_MAX_CHARS = 200;
+export declare const THESIS_CATALYST_MAX_CHARS = 160;
+export declare const MAX_PERSISTED_THESES = 60;
+export declare function thesisKey(venue: Venue, positionId: number): string;
+export declare function hasInvalidationCondition(inv: ThesisInvalidation): boolean;
+export declare function coerceThesis(raw: unknown): Thesis | undefined;
+export interface BindThesisInput {
+    thesis: Thesis;
+    venue: "futures" | "pm";
+    positionId: number;
+    openedAt: string;
+    side?: string;
+    symbol?: string;
+    entryPrice?: number;
+    source?: string;
+    slug?: string;
+    outcomeExternalMarketId?: string;
+    entryProbability?: number;
+}
+export interface BoundThesis {
+    thesis: PositionThesis;
+    notes: string[];
+}
+export declare function bindThesis(input: BindThesisInput): BoundThesis;
+export declare function holdMinutesOf(openedAt: string | undefined, fallback: string, nowMs: number): number;
+export declare function evaluateFuturesThesis(t: PositionThesis, pos: OpenPosition, nowMs: number): ThesisView;
+export declare function evaluatePmThesis(t: PositionThesis, pos: PmPosition, nowMs: number): ThesisView;
+export declare function attachTheses(observation: Observation, state: RunState, nowMs: number, opts: {
+    prunePm: boolean;
+}): {
+    attached: number;
+    pruned: string[];
+};
+export declare function thesisExits(observation: Observation): OpenPosition[];
+export declare function rememberThesis(state: RunState, thesis: PositionThesis): void;
+export declare function forgetThesis(state: RunState, key: string): void;
+export declare function describeInvalidation(inv: ThesisInvalidation): string;

package/dist/agent/thesis.js

@@ -0,0 +1,319 @@
+// Thesis exits (slice 2 of "house agents are not fun", 2026-09-02).
+//
+// A position is opened ON a thesis and leaves when that thesis is INVALIDATED,
+// not only when a stop-loss / take-profit fires or a small adverse tick spooks
+// the model. The model states the thesis inside its open action; the runner
+// sanitizes it side-aware, persists it with the position (RunState.theses,
+// keyed "<venue>:<positionId>") and re-evaluates the machine-checkable parts
+// every cycle: price levels against the live mark, probability levels against
+// the outcome's current market probability, time in trade against the time
+// stop. A futures position whose thesis broke is closed by the runner; PM has
+// no close endpoint, so an invalidated PM thesis is surfaced to the model (do
+// not add; let it settle). The free-text catalyst is never machine-evaluated:
+// the model re-judges it while it manages the position.
+//
+// Pure functions over plain objects; nowMs is injected so every rule is
+// testable without timers. Nothing here widens a cap or touches the kill
+// switch: a thesis exit is a risk-REDUCING close, and the runner executes it
+// only after the kill-switch and drawdown checks have passed.
+// A time stop shorter than an hour on a 3-minute cadence is the churn this
+// slice exists to end; longer than 30 days is not a time stop.
+export const THESIS_MIN_HOLD_MINUTES = 60;
+export const THESIS_MAX_HOLD_MINUTES = 60 * 24 * 30;
+export const THESIS_SUMMARY_MAX_CHARS = 200;
+export const THESIS_CATALYST_MAX_CHARS = 160;
+// Bound the persisted map so a runaway fleet member cannot grow the state JSON.
+export const MAX_PERSISTED_THESES = 60;
+const LEVEL_KEYS = [
+    "priceBelow",
+    "priceAbove",
+    "probabilityBelow",
+    "probabilityAbove",
+    "maxHoldMinutes",
+];
+export function thesisKey(venue, positionId) {
+    return `${venue}:${positionId}`;
+}
+// A finite positive number, tolerating the stringified numbers small models
+// emit ("64000"). Anything else is absent.
+function finitePositive(v) {
+    const n = typeof v === "string" && v.trim() !== "" ? Number(v) : v;
+    return typeof n === "number" && Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function cleanText(v, max) {
+    if (typeof v !== "string")
+        return undefined;
+    const s = v.replace(/\s+/g, " ").trim();
+    return s ? s.slice(0, max) : undefined;
+}
+function readInvalidation(raw) {
+    const out = {};
+    for (const k of LEVEL_KEYS) {
+        const n = finitePositive(raw[k]);
+        if (n != null)
+            out[k] = n;
+    }
+    const catalyst = cleanText(raw.catalyst, THESIS_CATALYST_MAX_CHARS);
+    if (catalyst)
+        out.catalyst = catalyst;
+    return out;
+}
+export function hasInvalidationCondition(inv) {
+    return LEVEL_KEYS.some((k) => inv[k] != null) || !!inv.catalyst;
+}
+// Parse a model-emitted thesis. TOLERANT by design (like forecastProbability):
+// a missing / malformed thesis becomes undefined and never fails the action.
+// Accepts the nested contract {summary, invalidation:{...}} and, for weak
+// models, a flattened {summary, priceBelow, ...}. Numbers may be strings.
+export function coerceThesis(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const o = raw;
+    const nested = o.invalidation &&
+        typeof o.invalidation === "object" &&
+        !Array.isArray(o.invalidation)
+        ? o.invalidation
+        : undefined;
+    const invalidation = readInvalidation(nested ?? o);
+    const summary = cleanText(o.summary, THESIS_SUMMARY_MAX_CHARS);
+    if (!summary && !hasInvalidationCondition(invalidation))
+        return undefined;
+    return { summary: summary ?? "(no summary stated)", invalidation };
+}
+// Bind a thesis to a freshly opened position, sanitizing it SIDE-AWARE so a
+// wrong-side level can never fire on the next tick: a rising price is never
+// what invalidates a long, a falling one never invalidates a short; for a YES
+// bet the odds must FALL to break it, for a NO bet they must RISE. Levels on the
+// wrong side of entry, levels for the other venue, and out-of-range values are
+// dropped (never silently re-signed); the time stop is clamped to the floor /
+// ceiling. Every drop or clamp is reported in `notes`.
+export function bindThesis(input) {
+    const notes = [];
+    const inv = { ...input.thesis.invalidation };
+    const side = (input.side ?? "").toLowerCase();
+    const drop = (k, why) => {
+        if (inv[k] == null)
+            return;
+        delete inv[k];
+        notes.push(`dropped ${k}: ${why}`);
+    };
+    if (input.venue === "futures") {
+        drop("probabilityBelow", "not a coin condition");
+        drop("probabilityAbove", "not a coin condition");
+        if (side === "short") {
+            drop("priceBelow", "a falling price never invalidates a short");
+            if (inv.priceAbove != null &&
+                input.entryPrice != null &&
+                inv.priceAbove <= input.entryPrice) {
+                drop("priceAbove", `must be above entry ${input.entryPrice}`);
+            }
+        }
+        else {
+            drop("priceAbove", "a rising price never invalidates a long");
+            if (inv.priceBelow != null &&
+                input.entryPrice != null &&
+                inv.priceBelow >= input.entryPrice) {
+                drop("priceBelow", `must be below entry ${input.entryPrice}`);
+            }
+        }
+    }
+    else {
+        drop("priceBelow", "not a prediction-market condition");
+        drop("priceAbove", "not a prediction-market condition");
+        for (const k of ["probabilityBelow", "probabilityAbove"]) {
+            if (inv[k] != null && inv[k] > 100)
+                drop(k, "0..100 points");
+        }
+        if (side === "no") {
+            drop("probabilityBelow", "falling odds never invalidate a NO");
+            if (inv.probabilityAbove != null &&
+                input.entryProbability != null &&
+                inv.probabilityAbove <= input.entryProbability) {
+                drop("probabilityAbove", `must be above entry ${input.entryProbability}`);
+            }
+        }
+        else {
+            drop("probabilityAbove", "rising odds never invalidate a YES");
+            if (inv.probabilityBelow != null &&
+                input.entryProbability != null &&
+                inv.probabilityBelow >= input.entryProbability) {
+                drop("probabilityBelow", `must be below entry ${input.entryProbability}`);
+            }
+        }
+    }
+    if (inv.maxHoldMinutes != null) {
+        const raw = inv.maxHoldMinutes;
+        const clamped = Math.min(THESIS_MAX_HOLD_MINUTES, Math.max(THESIS_MIN_HOLD_MINUTES, Math.round(raw)));
+        if (clamped !== raw) {
+            notes.push(`maxHoldMinutes ${raw} clamped to ${clamped}`);
+            inv.maxHoldMinutes = clamped;
+        }
+    }
+    const thesis = {
+        summary: input.thesis.summary,
+        invalidation: inv,
+        venue: input.venue,
+        positionId: input.positionId,
+        openedAt: input.openedAt,
+    };
+    if (input.symbol)
+        thesis.symbol = input.symbol;
+    if (side)
+        thesis.side = side;
+    if (input.source)
+        thesis.source = input.source;
+    if (input.slug)
+        thesis.slug = input.slug;
+    if (input.outcomeExternalMarketId)
+        thesis.outcomeExternalMarketId = input.outcomeExternalMarketId;
+    if (input.entryPrice != null)
+        thesis.entryPrice = input.entryPrice;
+    if (input.entryProbability != null)
+        thesis.entryProbability = input.entryProbability;
+    return { thesis, notes };
+}
+// Whole minutes in the trade, from the position's own openedAt (the server's
+// clock) when present, else the openedAt recorded at bind time.
+export function holdMinutesOf(openedAt, fallback, nowMs) {
+    const t = Date.parse(openedAt ?? fallback);
+    if (!Number.isFinite(t))
+        return 0;
+    return Math.max(0, Math.round((nowMs - t) / 60_000));
+}
+function view(t, holdMinutes, invalidatedBy) {
+    return {
+        summary: t.summary,
+        invalidation: t.invalidation,
+        holdMinutes,
+        status: invalidatedBy ? "invalidated" : "intact",
+        ...(invalidatedBy ? { invalidatedBy } : {}),
+    };
+}
+// Evaluate a futures thesis against the live position for THIS cycle. Price
+// levels are checked against the mark (at-or-beyond), then the time stop. A
+// position with no mark this cycle is judged on the time stop only.
+export function evaluateFuturesThesis(t, pos, nowMs) {
+    const holdMinutes = holdMinutesOf(pos.openedAt, t.openedAt, nowMs);
+    const inv = t.invalidation;
+    const mark = pos.markPrice;
+    let invalidatedBy;
+    if (typeof mark === "number" && Number.isFinite(mark)) {
+        if (inv.priceBelow != null && mark <= inv.priceBelow) {
+            invalidatedBy = `mark ${mark} at or below priceBelow ${inv.priceBelow}`;
+        }
+        else if (inv.priceAbove != null && mark >= inv.priceAbove) {
+            invalidatedBy = `mark ${mark} at or above priceAbove ${inv.priceAbove}`;
+        }
+    }
+    if (!invalidatedBy &&
+        inv.maxHoldMinutes != null &&
+        holdMinutes >= inv.maxHoldMinutes) {
+        invalidatedBy = `held ${holdMinutes}m, time stop ${inv.maxHoldMinutes}m`;
+    }
+    return view(t, holdMinutes, invalidatedBy);
+}
+// Evaluate a prediction-market thesis against the outcome's CURRENT market
+// probability (0..100 points, present only while the position is open).
+export function evaluatePmThesis(t, pos, nowMs) {
+    const holdMinutes = holdMinutesOf(pos.openedAt, t.openedAt, nowMs);
+    const inv = t.invalidation;
+    const cur = pos.currentProbability;
+    let invalidatedBy;
+    if (typeof cur === "number" && Number.isFinite(cur)) {
+        if (inv.probabilityBelow != null && cur <= inv.probabilityBelow) {
+            invalidatedBy = `probability ${cur} at or below probabilityBelow ${inv.probabilityBelow}`;
+        }
+        else if (inv.probabilityAbove != null && cur >= inv.probabilityAbove) {
+            invalidatedBy = `probability ${cur} at or above probabilityAbove ${inv.probabilityAbove}`;
+        }
+    }
+    if (!invalidatedBy &&
+        inv.maxHoldMinutes != null &&
+        holdMinutes >= inv.maxHoldMinutes) {
+        invalidatedBy = `held ${holdMinutes}m, time stop ${inv.maxHoldMinutes}m`;
+    }
+    return view(t, holdMinutes, invalidatedBy);
+}
+// Attach the evaluated thesis to every open position that has one and prune
+// theses whose position is gone (closed, stopped, liquidated, settled). Futures
+// positions are a required read, so a missing futures position is truly gone;
+// PM theses are pruned only when the caller actually read the pm book.
+export function attachTheses(observation, state, nowMs, opts) {
+    const theses = state.theses;
+    if (!theses)
+        return { attached: 0, pruned: [] };
+    const live = new Set();
+    let attached = 0;
+    for (const pos of observation.openPositions) {
+        if (pos.venue !== "futures")
+            continue;
+        const key = thesisKey("futures", pos.id);
+        live.add(key);
+        const t = theses[key];
+        if (!t)
+            continue;
+        pos.thesis = evaluateFuturesThesis(t, pos, nowMs);
+        attached += 1;
+    }
+    for (const pos of observation.pmPositions ?? []) {
+        const key = thesisKey("pm", pos.id);
+        live.add(key);
+        const t = theses[key];
+        if (!t)
+            continue;
+        pos.thesis = evaluatePmThesis(t, pos, nowMs);
+        attached += 1;
+    }
+    const pruned = [];
+    for (const key of Object.keys(theses)) {
+        if (live.has(key))
+            continue;
+        const t = theses[key];
+        if (t.venue === "pm" && !opts.prunePm)
+            continue;
+        if (t.venue === "spot")
+            continue; // never bound today; defensive
+        delete theses[key];
+        pruned.push(key);
+    }
+    return { attached, pruned };
+}
+// The futures positions the runner must close this cycle: thesis invalidated.
+export function thesisExits(observation) {
+    return observation.openPositions.filter((p) => p.venue === "futures" && p.thesis?.status === "invalidated");
+}
+export function rememberThesis(state, thesis) {
+    const theses = { ...(state.theses ?? {}) };
+    theses[thesisKey(thesis.venue, thesis.positionId)] = thesis;
+    const keys = Object.keys(theses);
+    if (keys.length > MAX_PERSISTED_THESES) {
+        keys.sort((a, b) => Date.parse(theses[a].openedAt) - Date.parse(theses[b].openedAt));
+        for (const k of keys.slice(0, keys.length - MAX_PERSISTED_THESES))
+            delete theses[k];
+    }
+    state.theses = theses;
+}
+export function forgetThesis(state, key) {
+    if (!state.theses || !(key in state.theses))
+        return;
+    const theses = { ...state.theses };
+    delete theses[key];
+    state.theses = theses;
+}
+// One-line rendering for logs and the journal.
+export function describeInvalidation(inv) {
+    const parts = [];
+    if (inv.priceBelow != null)
+        parts.push(`priceBelow ${inv.priceBelow}`);
+    if (inv.priceAbove != null)
+        parts.push(`priceAbove ${inv.priceAbove}`);
+    if (inv.probabilityBelow != null)
+        parts.push(`probabilityBelow ${inv.probabilityBelow}`);
+    if (inv.probabilityAbove != null)
+        parts.push(`probabilityAbove ${inv.probabilityAbove}`);
+    if (inv.maxHoldMinutes != null)
+        parts.push(`time stop ${inv.maxHoldMinutes}m`);
+    if (inv.catalyst)
+        parts.push(`catalyst: ${inv.catalyst}`);
+    return parts.length > 0 ? parts.join(", ") : "no condition";
+}