@reefclaw/openclaw-plugin 0.1.4 → 0.1.6

package/portfolio/wave9-policy.js

@@ -0,0 +1,183 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/portfolio/wave9-policy.ts
+// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
+//
+// This copy exists because this package builds with tsc and deploys as a
+// self-contained tree that strips workspace deps, so it cannot import
+// @reefclaw/shared runtime code across the deploy boundary.
+// Canonical frozen Wave 9 daily signal policy used by the default-off runtime parity
+// observer. This deliberately calls the same generated condition registry and
+// ATR implementation as the intelligence backtest instead of reimplementing
+// momentum semantics in the plugin.
+import { computeATR } from '../shared/indicators.js';
+import { evaluateConditions } from '../signals/conditions/registry.js';
+export const DAY_MS = 24 * 60 * 60 * 1_000;
+export const WAVE9_LOOKBACK_DAYS = 28;
+export const WAVE9_ATR_PERIOD = 14;
+export const WAVE9_ATR_MULTIPLE = 3;
+export const WAVE9_CONTEXT_BARS = 250;
+export const WAVE9_LONG_STRATEGY = 'tsmom_28d_long_flat_reversal_1d';
+export const WAVE9_SHORT_STRATEGY = 'tsmom_28d_short_flat_reversal_1d';
+export const WAVE9_SYMBOL_PRIORITY = [
+    'BTCUSDT',
+    'ETHUSDT',
+    'SOLUSDT',
+    'BNBUSDT',
+    'XRPUSDT',
+    'DOGEUSDT',
+    'ADAUSDT',
+    'LINKUSDT',
+];
+export const WAVE9_STRATEGY_PRIORITY = [
+    WAVE9_LONG_STRATEGY,
+    WAVE9_SHORT_STRATEGY,
+];
+function requireFinitePositive(value, label) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`${label} must be a positive finite number`);
+    }
+}
+/**
+ * Return the exact completed-daily context visible at a UTC daily boundary.
+ * The function is intentionally fail-closed: unordered, duplicated, gapped,
+ * non-UTC, or stale candles are rejected rather than silently repaired.
+ */
+export function completedDailyContext(rawBars, eventTime) {
+    const eventMs = eventTime.getTime();
+    if (!Number.isFinite(eventMs) || eventMs % DAY_MS !== 0) {
+        throw new Error('Wave 9 evaluation time must be a finite UTC daily boundary');
+    }
+    let previous = Number.NEGATIVE_INFINITY;
+    for (const [index, bar] of rawBars.entries()) {
+        const time = bar.time.getTime();
+        if (!Number.isFinite(time) || time % DAY_MS !== 0) {
+            throw new Error(`daily bar ${index} is not aligned to UTC midnight`);
+        }
+        if (time <= previous) {
+            throw new Error('daily bars must be strictly chronological and unique');
+        }
+        previous = time;
+        requireFinitePositive(bar.open, `daily bar ${index} open`);
+        requireFinitePositive(bar.high, `daily bar ${index} high`);
+        requireFinitePositive(bar.low, `daily bar ${index} low`);
+        requireFinitePositive(bar.close, `daily bar ${index} close`);
+        if (!Number.isFinite(bar.volume) || bar.volume < 0) {
+            throw new Error(`daily bar ${index} volume must be finite and non-negative`);
+        }
+        if (bar.high < Math.max(bar.open, bar.close) || bar.low > Math.min(bar.open, bar.close)) {
+            throw new Error(`daily bar ${index} has invalid OHLC geometry`);
+        }
+    }
+    const completed = rawBars
+        .filter((bar) => bar.time.getTime() + DAY_MS <= eventMs)
+        .slice(-WAVE9_CONTEXT_BARS);
+    if (completed.length <= WAVE9_LOOKBACK_DAYS + 1) {
+        throw new Error(`Wave 9 requires at least ${WAVE9_LOOKBACK_DAYS + 2} completed daily bars`);
+    }
+    const expectedLastOpen = eventMs - DAY_MS;
+    const lastOpen = completed[completed.length - 1].time.getTime();
+    if (lastOpen !== expectedLastOpen) {
+        throw new Error(`latest completed daily bar must open at ${new Date(expectedLastOpen).toISOString()}`);
+    }
+    for (let index = 1; index < completed.length; index++) {
+        const prior = completed[index - 1].time.getTime();
+        const current = completed[index].time.getTime();
+        if (current - prior !== DAY_MS) {
+            throw new Error(`daily history has a gap between ${completed[index - 1].time.toISOString()} and ${completed[index].time.toISOString()}`);
+        }
+    }
+    return completed.map((bar) => ({ ...bar, time: new Date(bar.time) }));
+}
+function makeContext(bars, atr14) {
+    const latest = bars[bars.length - 1];
+    return {
+        symbol: 'WAVE9',
+        timestamp: new Date(latest.time.getTime() + DAY_MS),
+        ohlcv1h: bars,
+        ohlcv5m: [],
+        ohlcv4h: [],
+        ohlcv1d: bars,
+        currentPrice: latest.close,
+        atr14,
+        obImbalance: 0.5,
+        fundingRates: [],
+        fundingMean: 0,
+        fundingStd: 0.0001,
+        oiValues: [],
+        liqNearEntry: 0,
+        tradeFlow: [],
+        regime: 'UNKNOWN',
+        regimeConfidence: 0,
+    };
+}
+function conditionMet(context, type, params, direction) {
+    const result = evaluateConditions([{ type, params }], context, direction);
+    if (result.conditions.length !== 1 || result.conditions[0].name !== type) {
+        throw new Error(`canonical condition registry did not evaluate ${type}`);
+    }
+    return result.conditions[0].met;
+}
+/** Evaluate the exact Wave 9 entry-transition and signal-reversal semantics. */
+export function evaluateWave9Daily(rawBars, eventTime) {
+    const bars = completedDailyContext(rawBars, eventTime);
+    const highs = bars.map((bar) => bar.high);
+    const lows = bars.map((bar) => bar.low);
+    const closes = bars.map((bar) => bar.close);
+    const atr14 = computeATR(highs, lows, closes, WAVE9_ATR_PERIOD);
+    requireFinitePositive(atr14, 'Wave 9 daily ATR(14)');
+    const context = makeContext(bars, atr14);
+    const currentClose = closes[closes.length - 1];
+    const currentPrior = closes[closes.length - 1 - WAVE9_LOOKBACK_DAYS];
+    const previousClose = closes[closes.length - 2];
+    const previousPrior = closes[closes.length - 2 - WAVE9_LOOKBACK_DAYS];
+    const currentReturn = (currentClose - currentPrior) / currentPrior;
+    const previousReturn = (previousClose - previousPrior) / previousPrior;
+    if (!Number.isFinite(currentReturn) || !Number.isFinite(previousReturn)) {
+        throw new Error('Wave 9 momentum inputs are not finite');
+    }
+    const longEntry = conditionMet(context, 'return_momentum_zero_cross', { tfHours: 24, lookback: WAVE9_LOOKBACK_DAYS, dirSign: 1 }, 'LONG');
+    const shortEntry = conditionMet(context, 'return_momentum_zero_cross', { tfHours: 24, lookback: WAVE9_LOOKBACK_DAYS, dirSign: -1 }, 'SHORT');
+    const exitLong = conditionMet(context, 'return_momentum', {
+        tfHours: 24,
+        lookback: WAVE9_LOOKBACK_DAYS,
+        minReturnPct: 0,
+        maxAbsReturnPct: 0,
+        dirSign: -1,
+        mode: 1,
+    }, 'SHORT');
+    const exitShort = conditionMet(context, 'return_momentum', {
+        tfHours: 24,
+        lookback: WAVE9_LOOKBACK_DAYS,
+        minReturnPct: 0,
+        maxAbsReturnPct: 0,
+        dirSign: 1,
+        mode: 1,
+    }, 'LONG');
+    const entries = [];
+    if (longEntry) {
+        entries.push({
+            strategy: WAVE9_LONG_STRATEGY,
+            direction: 'LONG',
+            stopPrice: currentClose - atr14 * WAVE9_ATR_MULTIPLE,
+        });
+    }
+    if (shortEntry) {
+        entries.push({
+            strategy: WAVE9_SHORT_STRATEGY,
+            direction: 'SHORT',
+            stopPrice: currentClose + atr14 * WAVE9_ATR_MULTIPLE,
+        });
+    }
+    return {
+        eventTime: eventTime.toISOString(),
+        completedDailyOpen: bars[bars.length - 1].time.toISOString(),
+        currentReturn,
+        previousReturn,
+        atr14,
+        referencePrice: currentClose,
+        entries,
+        exitLong,
+        exitShort,
+        sourceBarCount: bars.length,
+    };
+}

package/signals/conditions/registry.js

@@ -777,6 +777,56 @@ register('return_momentum', (ctx, params, direction) => {
             : `${lookback}-bar ${tfHours}h return ${(ret * 100).toFixed(2)}% fails ${label} threshold ${(minReturnPct * 100).toFixed(1)}%${capText}`,
     };
 });
+// Strict return-momentum episode transition. Unlike return_momentum, this is
+// an event rather than a level: it fires once when the lookback return crosses
+// zero (or an explicit threshold), then remains false until the sign resets.
+// That makes stop-outs and capacity-rejected entries naturally lock out for
+// the rest of the same momentum episode.
+register('return_momentum_zero_cross', (ctx, params, direction) => {
+    const lookback = Math.max(1, Math.floor(params.lookback ?? 28));
+    const thresholdPct = Math.max(0, params.thresholdPct ?? 0);
+    const dirSign = params.dirSign ?? 0;
+    const tfHours = params.tfHours ?? 24;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length <= lookback + 1) {
+        return {
+            met: false,
+            value: 0,
+            threshold: thresholdPct * 100,
+            description: `Insufficient ${tfHours}h bars for return_momentum_zero_cross`,
+        };
+    }
+    const currentClose = bars[bars.length - 1].close;
+    const currentPrior = bars[bars.length - 1 - lookback].close;
+    const previousClose = bars[bars.length - 2].close;
+    const previousPrior = bars[bars.length - 2 - lookback].close;
+    const currentReturn = currentPrior > 0
+        ? (currentClose - currentPrior) / currentPrior
+        : Number.NaN;
+    const previousReturn = previousPrior > 0
+        ? (previousClose - previousPrior) / previousPrior
+        : Number.NaN;
+    const sign = dirSign !== 0
+        ? Math.sign(dirSign)
+        : direction === 'LONG' ? 1 : direction === 'SHORT' ? -1 : 0;
+    const met = Number.isFinite(currentReturn)
+        && Number.isFinite(previousReturn)
+        && (sign > 0
+            ? previousReturn <= thresholdPct && currentReturn > thresholdPct
+            : sign < 0
+                ? previousReturn >= -thresholdPct && currentReturn < -thresholdPct
+                : false);
+    return {
+        met,
+        value: Number.isFinite(currentReturn)
+            ? Math.round(currentReturn * 10000) / 100
+            : 0,
+        threshold: thresholdPct * 100,
+        description: Number.isFinite(currentReturn) && Number.isFinite(previousReturn)
+            ? `${lookback}-bar ${tfHours}h return moved from ${(previousReturn * 100).toFixed(2)}% to ${(currentReturn * 100).toFixed(2)}%`
+            : `Invalid ${tfHours}h prices for return_momentum_zero_cross`,
+    };
+});
 // ─── 32. rsi_multi_pivot_divergence ──────────────────────────────────
 // Strict N-pivot RSI divergence: price makes successively lower lows (or
 // higher highs) while RSI makes the opposite, with optional volume dry-up

package/simulator/exchange-simulator.js

@@ -205,6 +205,11 @@ export class ExchangeSimulator extends EventEmitter {
                 // Surface entry metadata (if available)
                 ...(p.metadata && {
                     setupType: p.metadata.setupType,
+                    missionId: p.metadata.missionId,
+                    candidateId: p.metadata.candidateId,
+                    strategy: p.metadata.strategy,
+                    accruedFundingUsd: p.metadata.accruedFundingUsd,
+                    fundingThroughTime: p.metadata.fundingThroughTime,
                     thesis: p.metadata.thesis,
                     stopPrice: p.metadata.stopPrice,
                     targetPrice: p.metadata.targetPrice,

package/simulator/fill-engine.js

@@ -53,7 +53,11 @@ export function parseSymbol(symbol) {
     if (parts.length !== 2) {
         throw new Error(`Invalid symbol format: ${symbol}. Expected BASE/QUOTE`);
     }
-    return { base: parts[0], quote: parts[1] };
+    const [quote, settle, ...extra] = parts[1].split(':');
+    if (!quote || extra.length > 0 || (settle !== undefined && settle !== quote)) {
+        throw new Error(`Invalid symbol format: ${symbol}. Expected BASE/QUOTE or BASE/QUOTE:QUOTE`);
+    }
+    return { base: parts[0], quote };
 }
 /**
  * Ensure a currency exists in the wallet with at least zero balance.

package/simulator/types.d.ts

@@ -83,7 +83,7 @@ export interface CurrencyBalance {
  *  - `exchange_stop` / `exchange_target`: exchange-native STOP_MARKET / TAKE_PROFIT_MARKET triggered on Binance
  *  - `cancelled_auto`: bracket reconciler cleaned up after detecting the position closed externally
  *  - `operator` / `agent` / `emergency`: explicit initiator */
-export type CloseReason = 'agent' | 'stop_watcher' | 'emergency' | 'operator' | 'bracket_attach_failed' | 'exchange_stop' | 'exchange_target' | 'cancelled_auto';
+export type CloseReason = 'agent' | 'stop_watcher' | 'emergency' | 'operator' | 'bracket_attach_failed' | 'exchange_stop' | 'exchange_target' | 'cancelled_auto' | 'wave9_signal_reversal' | 'liquidated' | 'adl' | 'venue_delisted';
 /** The agent's stated profit-realization plan, pinned at entry. PURE DATA /
  *  indication — the plugin does NOT enforce it; it is surfaced back so the agent
  *  can hold to its own plan instead of re-litigating. The agent fills the parts
@@ -107,6 +107,11 @@ export interface RealizationRule {
  *  moment of close. */
 export interface PositionMetadata {
     setupType?: string;
+    missionId?: string;
+    candidateId?: string;
+    strategy?: 'tsmom_28d_long_flat_reversal_1d' | 'tsmom_28d_short_flat_reversal_1d';
+    accruedFundingUsd?: number;
+    fundingThroughTime?: string;
     thesis?: string;
     stopPrice?: number;
     targetPrice?: number;

package/strategy/evaluator.d.ts

@@ -27,6 +27,8 @@ export interface StrategyConfig {
         params: Record<string, number>;
     };
     targetRMultiples: number[];
+    /** Dedicated portfolio catalog rows are not declarative generic strategies. */
+    executionModel?: string;
 }
 export interface StrategyRow {
     id: number;
@@ -55,6 +57,7 @@ export interface StrategyEvalResult {
     regime_confidence: number;
     summary: string;
 }
+export declare function isDeclarativeStrategyConfig(strategy: StrategyConfig): boolean;
 /**
  * Evaluate a strategy against a symbol's fact object.
  * Returns null if the strategy is regime-gated and the symbol's regime doesn't match.

package/strategy/evaluator.js

@@ -4,12 +4,17 @@
 // and optionally checks threshold-based conditions against indicator values.
 import { CONDITION_EVALUATORS } from './condition-registry.js';
 import { getCachedTradingParams } from '../trading-params-cache.js';
+export function isDeclarativeStrategyConfig(strategy) {
+    return strategy.executionModel === undefined || strategy.executionModel === 'declarative';
+}
 // ─── Evaluator ──────────────────────────────────────────────────────────
 /**
  * Evaluate a strategy against a symbol's fact object.
  * Returns null if the strategy is regime-gated and the symbol's regime doesn't match.
  */
 export function evaluateStrategy(strategy, fact) {
+    if (!isDeclarativeStrategyConfig(strategy))
+        return null;
     // Check regime gate
     if (strategy.regimeWhitelist.length > 0) {
         const matchesRegime = strategy.regimeWhitelist.some(r => r === fact.regime || r === 'ANY');

package/tools/assessment-validation.d.ts

@@ -31,6 +31,8 @@ export interface ClosePositionArgs {
     symbol: string;
     reason?: string;
     assessment?: CloseAssessment;
+    candidate_id?: string;
+    wave9_exit_token?: string;
 }
 export interface ValidationResult {
     ok: boolean;

package/tools/attach-brackets.d.ts

@@ -1,4 +1,6 @@
 import type { IExchangeAdapter } from '../exchange-adapter.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
+import type { Wave9LiveSymbolOwnershipCheck } from '../wave9/live-symbol-ownership.js';
 interface AttachBracketsArgs {
     symbol: string;
     stop_price?: number;
@@ -26,9 +28,12 @@ interface AttachBracketsSuccess {
     idempotent_no_op?: boolean;
     note?: string;
 }
-export declare function attachBracketsTool(args: AttachBracketsArgs, deps: {
+interface AttachBracketsDeps {
     adapter: IExchangeAdapter;
-}): Promise<AttachBracketsSuccess | {
+    operationLock?: TradingOperationLock;
+    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
+}
+export declare function attachBracketsTool(args: AttachBracketsArgs, deps: AttachBracketsDeps): Promise<AttachBracketsSuccess | {
     error: string;
 }>;
 export {};

package/tools/attach-brackets.js

@@ -41,6 +41,42 @@ export async function attachBracketsTool(args, deps) {
     if (!deps.adapter.isLive) {
         return { error: 'attach_brackets is live-mode only (it places exchange-side STOP/TP orders). In paper mode, use modify_stop / modify_target to set or move the position\'s protective levels in place — the paper stop-watcher enforces metadata.stopPrice.' };
     }
+    if (deps.checkWave9LiveSymbolOwnership && !deps.operationLock) {
+        return {
+            error: 'Live attach_brackets refused: the shared trading operation lock is required ' +
+                'while Wave 9 LIVE ownership checks are enabled.',
+        };
+    }
+    const attachLive = () => attachBracketsLive(args, deps);
+    try {
+        return deps.operationLock
+            ? await deps.operationLock.withAccountLock(`generic-attach-brackets-final:${args.symbol}`, attachLive)
+            : await attachLive();
+    }
+    catch (err) {
+        return { error: formatError(err) };
+    }
+}
+async function attachBracketsLive(args, deps) {
+    if (deps.checkWave9LiveSymbolOwnership) {
+        let ownership;
+        try {
+            ownership = await deps.checkWave9LiveSymbolOwnership(args.symbol);
+        }
+        catch (err) {
+            return {
+                error: `attach_brackets refused at mutation boundary: Wave 9 LIVE ownership check failed ` +
+                    `for ${args.symbol} (${formatError(err)}).`,
+            };
+        }
+        if (ownership.status === 'owned' || ownership.status === 'ambiguous') {
+            return {
+                error: `attach_brackets refused at mutation boundary: ${args.symbol} has ` +
+                    `${ownership.status} Wave 9 LIVE ownership (${ownership.reason}). ` +
+                    'Wave 9 protection is candidate-bound and cannot be replaced by the generic bracket tool.',
+            };
+        }
+    }
     const live = deps.adapter;
     const mgr = live.getBracketManager?.();
     const ledger = live.getBracketLedger?.();

package/tools/cancel-all-orders.d.ts

@@ -1,7 +1,9 @@
 import type { IExchangeAdapter } from '../exchange-adapter.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
 import type { CcxtOrder } from '../types.js';
 export declare function cancelAllOrdersTool(args: {
     symbol?: string;
 }, deps: {
     adapter: IExchangeAdapter;
+    operationLock?: TradingOperationLock;
 }): Promise<CcxtOrder[]>;

package/tools/cancel-all-orders.js

@@ -1,5 +1,8 @@
 // Tool: cancel_all_orders — cancel all open orders (paper or live)
 // NO readiness gate — emergency control (kill switch), must always work.
 export async function cancelAllOrdersTool(args, deps) {
-    return deps.adapter.cancelAllOrders(args.symbol);
+    const cancel = () => deps.adapter.cancelAllOrders(args.symbol);
+    return deps.adapter.isLive && deps.operationLock
+        ? deps.operationLock.withAccountLock(`generic-cancel-all-orders-final:${args.symbol ?? 'all'}`, cancel)
+        : cancel();
 }

package/tools/cancel-order.d.ts

@@ -1,10 +1,14 @@
 import type { IExchangeAdapter } from '../exchange-adapter.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
 import type { CcxtOrder } from '../types.js';
+import type { Wave9LiveSymbolOwnershipCheck } from '../wave9/live-symbol-ownership.js';
 export declare function cancelOrderTool(args: {
     id: string;
     symbol?: string;
 }, deps: {
     adapter: IExchangeAdapter;
+    operationLock?: TradingOperationLock;
+    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
 }): Promise<CcxtOrder | {
     error: string;
 }>;

package/tools/cancel-order.js

@@ -1,12 +1,58 @@
-// Tool: cancel_order — cancel a single order (paper or live)
-// NO readiness gate — emergency control, must always work.
+// Tool: cancel_order — cancel a single order (paper or live).
+// There is no readiness gate, but LIVE cancellation cannot individually strip
+// candidate-bound Wave 9 protection. The emergency escape is an explicit
+// operator close, which reduces exposure instead of leaving it naked.
 import { formatError } from '../logger.js';
 export async function cancelOrderTool(args, deps) {
     if (!args.id) {
         return { error: 'Order ID is required.' };
     }
+    if (!deps.adapter.isLive) {
+        try {
+            return await deps.adapter.cancelOrder(args.id, args.symbol);
+        }
+        catch (err) {
+            return { error: formatError(err) };
+        }
+    }
+    if (deps.checkWave9LiveSymbolOwnership && !deps.operationLock) {
+        return {
+            error: 'Live cancel_order refused: the shared trading operation lock is required ' +
+                'while Wave 9 LIVE ownership checks are enabled.',
+        };
+    }
+    const cancelLive = async () => {
+        let symbol = args.symbol?.trim();
+        if (!symbol) {
+            const matches = (await deps.adapter.getOpenOrders())
+                .filter((order) => order.id === args.id);
+            if (matches.length !== 1 || !matches[0].symbol) {
+                throw new Error(`cancel_order refused: order ${args.id} could not be resolved to exactly one ` +
+                    `trusted open-order symbol (matches=${matches.length}).`);
+            }
+            symbol = matches[0].symbol;
+        }
+        if (deps.checkWave9LiveSymbolOwnership) {
+            let ownership;
+            try {
+                ownership = await deps.checkWave9LiveSymbolOwnership(symbol);
+            }
+            catch (err) {
+                throw new Error(`cancel_order refused at mutation boundary: Wave 9 LIVE ownership check failed ` +
+                    `for ${symbol} (${formatError(err)}).`);
+            }
+            if (ownership.status === 'owned' || ownership.status === 'ambiguous') {
+                throw new Error(`cancel_order refused at mutation boundary: ${symbol} has ` +
+                    `${ownership.status} Wave 9 LIVE ownership (${ownership.reason}). ` +
+                    'Use operator_command to close the position instead of stripping candidate-bound protection.');
+            }
+        }
+        return deps.adapter.cancelOrder(args.id, symbol);
+    };
     try {
-        return await deps.adapter.cancelOrder(args.id, args.symbol);
+        return deps.operationLock
+            ? await deps.operationLock.withAccountLock(`generic-cancel-order-final:${args.id}`, cancelLive)
+            : await cancelLive();
     }
     catch (err) {
         return { error: formatError(err) };

package/tools/close-position.d.ts

@@ -4,6 +4,11 @@ import type { CcxtOrder } from '../types.js';
 import { type ClosePositionArgs } from './assessment-validation.js';
 import { type AutoCaptureContext } from '../ingest/position-auto-capture.js';
 import { type ExitGateMode } from '../config/position-review-config.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
+import type { Wave9LiveExecutionLedger } from '../wave9/live-execution-ledger.js';
+import type { Wave9LiveSymbolOwnershipCheck } from '../wave9/live-symbol-ownership.js';
+import { type Wave9LiveResidualProtectionResult } from '../wave9/live-residual-protection.js';
+import { type Wave9PaperAdmissionGuard } from '../wave9/paper-admission-guard.js';
 export declare function closePositionTool(args: ClosePositionArgs, deps: {
     binanceApi: PublicMarketDataApi;
     adapter: IExchangeAdapter;
@@ -11,6 +16,24 @@ export declare function closePositionTool(args: ClosePositionArgs, deps: {
     /** Override for tests — production reads from plugin-config.json on each
      *  call so the flag can be flipped without a restart. */
     exitGateMode?: ExitGateMode;
+    wave9AdmissionGuard?: Wave9PaperAdmissionGuard;
+    refreshPaperState?: () => void;
+    wave9TradingModeCheck?: () => string;
+    wave9VenueCheck?: () => string;
+    captureWave9PositionFingerprint?: (symbol: string) => Promise<{
+        fingerprint: string;
+        position: {
+            candidateId?: string;
+            missionId?: string;
+            setupType?: string;
+            side: 'long' | 'short';
+        };
+    }>;
+    wave9LiveLedger?: Wave9LiveExecutionLedger;
+    checkWave9LiveSymbolOwnership?: Wave9LiveSymbolOwnershipCheck;
+    reprotectWave9LiveResidual?: (adapter: IExchangeAdapter, ledger: Wave9LiveExecutionLedger, candidateId: string, symbol: string) => Promise<Wave9LiveResidualProtectionResult>;
+    operationLock?: TradingOperationLock;
+    operationLockHeld?: boolean;
 }): Promise<CcxtOrder | {
     error: string;
 }>;