@reefclaw/openclaw-plugin 0.1.5 → 0.1.7

package/live/stop-watcher.d.ts

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import type { IExchangeAdapter } from '../exchange-adapter.js';
-import type { CcxtPosition } from '../types.js';
+import type { CcxtOrder, CcxtPosition } from '../types.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
 export declare const DEFAULT_INTERVAL_MS = 10000;
 export interface StopTriggeredEvent {
     symbol: string;
@@ -9,6 +10,33 @@ export interface StopTriggeredEvent {
     markPrice: number;
     quantity: number;
 }
+/** Emitted with 'stop_closed' — carries the executed close order so listeners
+ *  (the journal auto-capture wiring in index.ts) can record the close with the
+ *  real fill. Without this, watcher closes bypassed the Position Decision
+ *  Journal entirely and left phantom-open journal positions (issue #199). */
+export interface StopClosedEvent extends StopTriggeredEvent {
+    order?: CcxtOrder;
+}
+export type Wave9StopCloseOutcome = {
+    status: 'flat';
+    detail: string;
+    candidateId: string;
+    symbol: string;
+} | {
+    status: 'protected' | 'manual_intervention';
+    detail: string;
+    candidateId: string;
+    symbol: string;
+    stopPrice: number;
+    residualQuantity?: number;
+    stopClientOrderId?: string;
+};
+/** Optional durable Wave 9 lifecycle. Generic watcher behavior is unchanged
+ *  when this is absent or the current position has no owned candidate. */
+export interface Wave9StopCloseLifecycle {
+    resolveCandidateId(position: CcxtPosition): Promise<string | undefined> | string | undefined;
+    settleAfterClose(candidateId: string, symbol: string): Promise<Wave9StopCloseOutcome>;
+}
 /** Decide whether a position has crossed its stop.
  *  Exported for direct unit-testing without spinning up a watcher loop. */
 export declare function isStopBreached(position: CcxtPosition): boolean;
@@ -16,6 +44,8 @@ export declare class PositionWatcher extends EventEmitter {
     private interval;
     private intervalMs;
     private adapter;
+    private readonly operationLock?;
+    private wave9CloseLifecycle?;
     /** Symbols currently awaiting a close RPC — second trigger in the same tick
      *  is suppressed so the watcher cannot double-close. Cleared after the close
      *  call resolves (success or failure). */
@@ -23,7 +53,10 @@ export declare class PositionWatcher extends EventEmitter {
     /** Symbols we've already logged a breach for this session, to avoid spamming
      *  the log every tick while the close is in flight. */
     private notifiedBreach;
-    constructor(adapter: IExchangeAdapter, intervalMs?: number);
+    constructor(adapter: IExchangeAdapter, intervalMs?: number, operationLock?: TradingOperationLock);
+    /** Configure this after the durable execution ledger is ready. Runtime
+     *  lifecycle hooks reapply it to every watcher after reconnect. */
+    setWave9CloseLifecycle(lifecycle?: Wave9StopCloseLifecycle): void;
     start(): void;
     stop(): void;
     /** Run one check cycle. Exposed for tests (skip setInterval). */

package/live/stop-watcher.js

@@ -45,6 +45,8 @@ export class PositionWatcher extends EventEmitter {
     interval = null;
     intervalMs;
     adapter;
+    operationLock;
+    wave9CloseLifecycle;
     /** Symbols currently awaiting a close RPC — second trigger in the same tick
      *  is suppressed so the watcher cannot double-close. Cleared after the close
      *  call resolves (success or failure). */
@@ -52,10 +54,16 @@ export class PositionWatcher extends EventEmitter {
     /** Symbols we've already logged a breach for this session, to avoid spamming
      *  the log every tick while the close is in flight. */
     notifiedBreach = new Set();
-    constructor(adapter, intervalMs = DEFAULT_INTERVAL_MS) {
+    constructor(adapter, intervalMs = DEFAULT_INTERVAL_MS, operationLock) {
         super();
         this.adapter = adapter;
         this.intervalMs = intervalMs;
+        this.operationLock = operationLock;
+    }
+    /** Configure this after the durable execution ledger is ready. Runtime
+     *  lifecycle hooks reapply it to every watcher after reconnect. */
+    setWave9CloseLifecycle(lifecycle) {
+        this.wave9CloseLifecycle = lifecycle;
     }
     start() {
         if (this.interval) {
@@ -130,10 +138,62 @@ export class PositionWatcher extends EventEmitter {
             quantity: position.contracts,
         };
         this.emit('stop_triggered', event);
+        // Captured close order for the 'stop_closed' event — set inside close()
+        // (which may run under the symbol lock) and read after it resolves.
+        let closeOrder;
+        const close = async () => {
+            let trustedPosition = position;
+            // Re-read after acquiring the shared trading boundary. A Wave 9
+            // reversal or another stop may have flattened the symbol while this
+            // watcher was queued.
+            if (this.operationLock) {
+                const current = await this.adapter.getPositionsOrNull(position.symbol);
+                if (current === null) {
+                    throw new Error('position recheck unavailable while holding trading operation lock');
+                }
+                const latest = current.find((candidate) => candidate.symbol === position.symbol);
+                if (!latest || !isStopBreached(latest)) {
+                    logger.info(TAG, `${position.symbol} no longer stop-triggered after locked recheck — skipping`);
+                    return 'skipped';
+                }
+                trustedPosition = latest;
+            }
+            let candidateId;
+            let ownershipError;
+            if (this.wave9CloseLifecycle) {
+                try {
+                    candidateId = await this.wave9CloseLifecycle.resolveCandidateId(trustedPosition);
+                }
+                catch (error) {
+                    ownershipError = formatError(error);
+                }
+            }
+            if (ownershipError) {
+                throw new Error(`Wave 9 ownership resolution failed before stop close submission: ${ownershipError}; ` +
+                    'IMMEDIATE MANUAL INTERVENTION REQUIRED');
+            }
+            closeOrder = await this.adapter.closePosition(trustedPosition.symbol, 'stop_watcher');
+            if (!candidateId || !this.wave9CloseLifecycle)
+                return 'closed';
+            const outcome = await this.wave9CloseLifecycle.settleAfterClose(candidateId, trustedPosition.symbol);
+            if (outcome.status === 'flat')
+                return 'closed';
+            if (outcome.status === 'protected') {
+                logger.warn(TAG, `Stop close left a Wave 9 residual on ${trustedPosition.symbol}; ` +
+                    `${outcome.detail}. The exact frozen stop is proven and the watcher will retry.`);
+                this.emit('stop_residual_protected', { ...event, ...outcome });
+                return 'residual_protected';
+            }
+            throw new Error(outcome.detail);
+        };
         try {
-            await this.adapter.closePosition(position.symbol, 'stop_watcher');
+            const result = this.operationLock
+                ? await this.operationLock.withSymbolLock(position.symbol, `stop_watcher:${position.symbol}`, close)
+                : await close();
+            if (result !== 'closed')
+                return;
             logger.info(TAG, `Auto-closed ${position.symbol} (reason=stop_watcher)`);
-            this.emit('stop_closed', event);
+            this.emit('stop_closed', { ...event, order: closeOrder });
         }
         catch (err) {
             const msg = formatError(err);

package/onboarding/runtime.d.ts

@@ -2,7 +2,9 @@ import type { IExchangeAdapter } from '../exchange-adapter.js';
 import type { ExchangeConfig, TradingMode } from '../types.js';
 import type { ExchangeSimulator } from '../simulator/exchange-simulator.js';
 import type { PaperMarketFeed } from '../simulator/paper-market-feed.js';
+import { LiveAdapter } from '../live/live-adapter.js';
 import { PositionWatcher } from '../live/stop-watcher.js';
+import type { TradingOperationLock } from '../lifecycle/trading-operation-lock.js';
 export interface MicroLiveConfig {
     sizeCapPercent?: number;
     maxPositionUSDT?: number;
@@ -13,6 +15,13 @@ export interface BuildAdapterInput {
     microLive?: MicroLiveConfig;
     simulator: ExchangeSimulator;
 }
+/** Wave 9 safety wiring is created only after its durable ledger is loaded.
+ *  Runtime reapplies these hooks to both the bootstrap objects and every
+ *  adapter/watcher built by a reconnect. */
+export interface Wave9LiveLifecycleHooks {
+    configureLiveAdapter?(adapter: LiveAdapter): void;
+    configurePositionWatcher?(watcher: PositionWatcher, adapter: IExchangeAdapter): void;
+}
 /** Pure-ish factory: builds an adapter for the requested mode.
  *  Falls back to PaperAdapter if a live mode is requested without credentials —
  *  callers should pre-validate via `modeRequiresCredentials`, but this
@@ -36,6 +45,13 @@ export declare class PluginRuntime {
      *  stops fire and NAV/uPnL stay live for non-dashboard symbols). Lives for
      *  the runtime's lifetime; started in paper, stopped in live. */
     private readonly _marketFeed;
+    private readonly operationLock?;
+    private wave9LiveLifecycleHooks?;
+    /** Observer applied to EVERY stop-watcher this runtime creates (reconnects
+     *  included). index.ts uses it to attach the journal auto-capture listener
+     *  for watcher closes (issue #199) — without it, a live<->paper reconnect
+     *  would silently shed the capture wiring. */
+    private readonly onWatcherCreated?;
     /** Reconnect is serialized — a second caller waits for the first to finish
      *  so we never tear down an adapter that's mid-rebuild. */
     private reconnectInFlight;
@@ -45,11 +61,14 @@ export declare class PluginRuntime {
         simulator: ExchangeSimulator;
         stopWatcher?: PositionWatcher | null;
         marketFeed?: PaperMarketFeed | null;
+        operationLock?: TradingOperationLock;
+        onWatcherCreated?: (watcher: PositionWatcher) => void;
     });
     get adapter(): IExchangeAdapter;
     get mode(): TradingMode;
     get stopWatcher(): PositionWatcher | null;
     get marketFeed(): PaperMarketFeed | null;
+    setWave9LiveLifecycleHooks(hooks?: Wave9LiveLifecycleHooks): void;
     /**
      * Swap the current adapter for a new one built from `next`. The old
      * adapter's background loops are stopped before the new one is wired in.

package/onboarding/runtime.js

@@ -15,6 +15,7 @@ import { PaperAdapter } from '../paper-adapter.js';
 import { LiveAdapter } from '../live/live-adapter.js';
 import { PositionWatcher } from '../live/stop-watcher.js';
 import { loadBracketMode } from '../config/brackets-config.js';
+import { loadStopWatcherIntervalMs } from '../config/plugin-config-io.js';
 import { logger, formatError } from '../logger.js';
 const TAG = 'plugin-runtime';
 /** Pure-ish factory: builds an adapter for the requested mode.
@@ -55,6 +56,13 @@ export class PluginRuntime {
      *  stops fire and NAV/uPnL stay live for non-dashboard symbols). Lives for
      *  the runtime's lifetime; started in paper, stopped in live. */
     _marketFeed;
+    operationLock;
+    wave9LiveLifecycleHooks;
+    /** Observer applied to EVERY stop-watcher this runtime creates (reconnects
+     *  included). index.ts uses it to attach the journal auto-capture listener
+     *  for watcher closes (issue #199) — without it, a live<->paper reconnect
+     *  would silently shed the capture wiring. */
+    onWatcherCreated;
     /** Reconnect is serialized — a second caller waits for the first to finish
      *  so we never tear down an adapter that's mid-rebuild. */
     reconnectInFlight = null;
@@ -64,11 +72,22 @@ export class PluginRuntime {
         this.simulator = initial.simulator;
         this._stopWatcher = initial.stopWatcher ?? null;
         this._marketFeed = initial.marketFeed ?? null;
+        this.operationLock = initial.operationLock;
+        this.onWatcherCreated = initial.onWatcherCreated;
     }
     get adapter() { return this._adapter; }
     get mode() { return this._mode; }
     get stopWatcher() { return this._stopWatcher; }
     get marketFeed() { return this._marketFeed; }
+    setWave9LiveLifecycleHooks(hooks) {
+        this.wave9LiveLifecycleHooks = hooks;
+        if (this._adapter instanceof LiveAdapter) {
+            hooks?.configureLiveAdapter?.(this._adapter);
+        }
+        if (this._stopWatcher) {
+            hooks?.configurePositionWatcher?.(this._stopWatcher, this._adapter);
+        }
+    }
     /**
      * Swap the current adapter for a new one built from `next`. The old
      * adapter's background loops are stopped before the new one is wired in.
@@ -82,7 +101,9 @@ export class PluginRuntime {
         if (this.reconnectInFlight) {
             await this.reconnectInFlight;
         }
-        const run = this.doReconnect(next, deps);
+        const run = this.operationLock
+            ? this.operationLock.withAccountLock('runtime-reconnect', () => this.doReconnect(next, deps))
+            : this.doReconnect(next, deps);
         this.reconnectInFlight = run.finally(() => {
             this.reconnectInFlight = null;
         });
@@ -117,6 +138,11 @@ export class PluginRuntime {
             microLive: next.microLive,
             simulator: this.simulator,
         });
+        // Install autonomous protection callbacks before initialization can emit
+        // user-data or bracket-reconciler events.
+        if (fresh instanceof LiveAdapter) {
+            this.wave9LiveLifecycleHooks?.configureLiveAdapter?.(fresh);
+        }
         // 4. Fire async init for live adapters (non-blocking — readiness flips
         //    INIT_PENDING → READY/DEGRADED/BLOCKED on its own).
         if (fresh instanceof LiveAdapter) {
@@ -133,8 +159,13 @@ export class PluginRuntime {
         this._adapter = fresh;
         this._mode = next.mode;
         deps.adapterDeps.adapter = fresh;
-        // 6. Start a new stop-watcher bound to the new adapter.
-        const watcher = new PositionWatcher(fresh);
+        // 6. Start a new stop-watcher bound to the new adapter. Re-read the
+        //    operator's cadence override — building with `undefined` here
+        //    silently reverted plugin-config `stopWatcher.intervalMs` to the
+        //    default on every reconnect.
+        const watcher = new PositionWatcher(fresh, loadStopWatcherIntervalMs(), this.operationLock);
+        this.wave9LiveLifecycleHooks?.configurePositionWatcher?.(watcher, fresh);
+        this.onWatcherCreated?.(watcher);
         watcher.start();
         this._stopWatcher = watcher;
         // 7. Paper market feed follows the mode: run it when the new adapter is

package/openclaw.plugin.json

@@ -36,6 +36,7 @@
       "get_market_intel",
       "get_regime",
       "get_signals",
+      "get_wave9_status",
       "get_analytics",
       "get_orderbook",
       "get_volume_profile",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reefclaw/openclaw-plugin",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "ReefClaw trading plugin for OpenClaw \u2014 paper trading with real Binance market data, plus the ReefClaw dashboard connector (supervised by OpenClaw, no service manager needed). Install: /plugins install clawhub:@reefclaw/openclaw-plugin",
   "type": "module",
   "main": "index.js",
@@ -22,7 +22,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@reefclaw/shared": "0.1.1",
+    "@reefclaw/shared": "0.1.2",
     "ccxt": "4.5.37",
     "json5": "2.2.3",
     "ws": "8.19.0"

package/portfolio/reentry-tracker.d.ts

@@ -0,0 +1,36 @@
+export interface ReentryExitRecord {
+    /** Canonical symbol (no settle suffix). */
+    symbol: string;
+    /** setup_type / strategy name from the entry metadata, when known. */
+    setupType?: string;
+    side: 'long' | 'short';
+    /** Whether the closed trade realized a loss (drives the stronger caution). */
+    wasLoss?: boolean;
+    closedAtMs: number;
+}
+/** Signal-bar duration for a strategy/setup name. Name-suffix inference:
+ *  `..._4h` → 240min, `..._1d` / daily → 1440min, `..._Nh` → N×60. Unknown
+ *  shapes default to 60min so short-TF strategies are never over-warned. */
+export declare function strategyBarMinutes(name: string | undefined): number;
+export declare class ReentryTracker {
+    private records;
+    private readonly filePath;
+    private readonly dir;
+    constructor(pluginId?: string, opts?: {
+        basePath?: string;
+    });
+    /** Record a position exit. Never throws (best-effort persistence). */
+    recordExit(record: Omit<ReentryExitRecord, 'symbol'> & {
+        symbol: string;
+    }): void;
+    /** Most recent exit for (symbol[, setup]). A setup-specific record wins over
+     *  a symbol-only match so multi-strategy books get precise cautions. */
+    lastExit(symbol: string, setupType?: string): ReentryExitRecord | undefined;
+    /** Structured caution when (symbol, strategy) was already traded within the
+     *  current signal bar. Undefined = no caution. Pure indication (issue #204):
+     *  the agent decides; nothing here blocks an order. */
+    cautionFor(symbol: string, strategy: string | undefined, nowMs?: number): string | undefined;
+    /** Test seam. */
+    getRecords(): readonly ReentryExitRecord[];
+    private persist;
+}

package/portfolio/reentry-tracker.js

@@ -0,0 +1,127 @@
+// Re-entry tracker — records recent position exits per (symbol, setup) so the
+// entry funnel (scan_pairs / get_signals) can flag setups the agent already
+// traded within the current signal bar (issue #204).
+//
+// WHY: the validated backtests for the 4h/1d templates have one-trade-per-
+// signal semantics — a signal bar produces at most one trade. Live, the 4h
+// condition stays true for hours, so after every exit the next heartbeat
+// re-entered the same setup: measured 19× the backtest cadence with 79-minute
+// median holds, including 22 same-direction re-entries within one bar of a
+// LOSING close (2026-07-14 → 07-20 HL soak). Per the tools-not-mandates
+// doctrine this ships as STRUCTURED INDICATION — the annotation tells the
+// agent the setup was already traded this bar; it never blocks the order.
+//
+// Persistence: small JSON in the plugins base dir (same pattern as
+// position-state-store) so restarts don't blind the indication. Best-effort —
+// a persistence failure degrades to in-memory-only, never throws into the
+// trading path.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { logger, formatError } from '../logger.js';
+import { normalizeBracketSymbol } from '../live/bracket-ledger.js';
+import { resolvePluginsBaseDir } from '../util/plugin-paths.js';
+const TAG = 'reentry-tracker';
+const DEFAULT_PLUGIN_ID = 'reefclaw-paper-trading';
+const STATE_FILENAME = 'reentry-log.json';
+const MAX_RECORDS = 300;
+/** Signal-bar duration for a strategy/setup name. Name-suffix inference:
+ *  `..._4h` → 240min, `..._1d` / daily → 1440min, `..._Nh` → N×60. Unknown
+ *  shapes default to 60min so short-TF strategies are never over-warned. */
+export function strategyBarMinutes(name) {
+    if (!name)
+        return 60;
+    const lower = name.toLowerCase();
+    const hourMatch = lower.match(/_(\d{1,2})h\b|_(\d{1,2})h_|_(\d{1,2})h$/);
+    if (hourMatch) {
+        const h = Number(hourMatch[1] ?? hourMatch[2] ?? hourMatch[3]);
+        if (Number.isFinite(h) && h > 0)
+            return h * 60;
+    }
+    if (/_1d\b|_1d_|_1d$|daily/.test(lower))
+        return 1440;
+    return 60;
+}
+export class ReentryTracker {
+    records = [];
+    filePath;
+    dir;
+    constructor(pluginId, opts) {
+        const base = resolvePluginsBaseDir(opts?.basePath);
+        this.dir = join(base, pluginId ?? DEFAULT_PLUGIN_ID);
+        this.filePath = join(this.dir, STATE_FILENAME);
+        try {
+            if (!existsSync(this.dir))
+                mkdirSync(this.dir, { recursive: true });
+            if (existsSync(this.filePath)) {
+                const parsed = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+                if (Array.isArray(parsed?.records)) {
+                    this.records = parsed.records.filter((r) => typeof r?.symbol === 'string' && Number.isFinite(r?.closedAtMs));
+                }
+            }
+        }
+        catch (err) {
+            logger.warn(TAG, `load failed (${formatError(err)}) — starting empty`);
+            this.records = [];
+        }
+    }
+    /** Record a position exit. Never throws (best-effort persistence). */
+    recordExit(record) {
+        try {
+            this.records.push({ ...record, symbol: normalizeBracketSymbol(record.symbol) });
+            if (this.records.length > MAX_RECORDS) {
+                this.records = this.records.slice(-MAX_RECORDS);
+            }
+            this.persist();
+        }
+        catch (err) {
+            logger.warn(TAG, `recordExit failed: ${formatError(err)}`);
+        }
+    }
+    /** Most recent exit for (symbol[, setup]). A setup-specific record wins over
+     *  a symbol-only match so multi-strategy books get precise cautions. */
+    lastExit(symbol, setupType) {
+        const key = normalizeBracketSymbol(symbol);
+        let bySetup;
+        let bySymbol;
+        for (let i = this.records.length - 1; i >= 0; i--) {
+            const r = this.records[i];
+            if (r.symbol !== key)
+                continue;
+            if (!bySymbol)
+                bySymbol = r;
+            if (setupType && r.setupType === setupType) {
+                bySetup = r;
+                break;
+            }
+            if (!setupType)
+                break;
+        }
+        return bySetup ?? bySymbol;
+    }
+    /** Structured caution when (symbol, strategy) was already traded within the
+     *  current signal bar. Undefined = no caution. Pure indication (issue #204):
+     *  the agent decides; nothing here blocks an order. */
+    cautionFor(symbol, strategy, nowMs = Date.now()) {
+        const last = this.lastExit(symbol, strategy);
+        if (!last)
+            return undefined;
+        const barMin = strategyBarMinutes(strategy ?? last.setupType);
+        const agoMin = Math.round((nowMs - last.closedAtMs) / 60_000);
+        if (agoMin < 0 || agoMin > barMin)
+            return undefined;
+        const lossNote = last.wasLoss ? ' at a LOSS' : '';
+        return (`already traded this signal bar: exited a ${last.side} on this setup ${agoMin}m ago${lossNote} ` +
+            `(bar=${barMin}m). The validated backtest takes ONE trade per signal bar — re-enter only if ` +
+            `you can name what NEW information arrived since that exit.`);
+    }
+    /** Test seam. */
+    getRecords() {
+        return this.records;
+    }
+    persist() {
+        const payload = { schemaVersion: 1, records: this.records };
+        const tmp = `${this.filePath}.tmp`;
+        writeFileSync(tmp, JSON.stringify(payload), 'utf-8');
+        renameSync(tmp, this.filePath);
+    }
+}

package/portfolio/wave9-admission.d.ts

@@ -0,0 +1,67 @@
+import type { Direction } from '../signals/types.js';
+import { type Wave9StrategyName } from './wave9-policy.js';
+export interface Wave9AdmissionPolicy {
+    riskPct: number;
+    maxPositions: number;
+    maxOpenRiskPct: number;
+    maxGrossExposureMultiple: number;
+    maxPositionUsd: number;
+    feeBps: number;
+    slippageBps: number;
+    capEnforcement: 'admission_only_no_forced_deleveraging';
+    riskMeasure: 'fixed_initial_stop_risk_usd';
+}
+export declare const WAVE9_ADMISSION_POLICY: Readonly<Wave9AdmissionPolicy>;
+export interface Wave9AdmissionPosition {
+    candidateId: string;
+    symbol: string;
+    strategy: Wave9StrategyName;
+    direction: Direction;
+    entryPrice: number;
+    quantity: number;
+    markPrice: number;
+    initialStop: number;
+    dollarRiskUsd: number;
+    accruedFundingUsd: number;
+}
+export interface Wave9AdmissionState {
+    cashEquityUsd: number;
+    positions: Wave9AdmissionPosition[];
+}
+export interface Wave9AdmissionCandidate {
+    id: string;
+    eventTime: string;
+    symbol: string;
+    strategy: Wave9StrategyName;
+    direction: Direction;
+    referencePrice: number;
+    stopPrice: number;
+}
+export type Wave9AdmissionReason = 'accepted' | 'invalidGeometry' | 'symbolAlreadyOpen' | 'maxPositions' | 'maxGrossExposure' | 'maxOpenRisk' | 'invalidSizing';
+export interface Wave9AdmissionLedgerRow extends Wave9AdmissionPosition {
+    estimatedExitCostUsd: number;
+}
+export interface Wave9AdmissionDecision extends Wave9AdmissionCandidate {
+    accepted: boolean;
+    reason: Wave9AdmissionReason;
+    entryPrice?: number;
+    quantity?: number;
+    notionalUsd?: number;
+    riskUsd?: number;
+    projectedCashEquityUsd?: number;
+    projectedLiquidationEquityUsd?: number;
+    projectedGrossExposureUsd?: number;
+    projectedOpenRiskUsd?: number;
+    projectedOpenPositions?: number;
+    projectedPositionLedger?: Wave9AdmissionLedgerRow[];
+}
+export interface Wave9AdmissionBatchResult {
+    decisions: Wave9AdmissionDecision[];
+    state: Wave9AdmissionState;
+}
+/**
+ * Apply a same-event candidate batch in the exact frozen priority. The caller
+ * must release stops and completed-daily reversals before invoking this
+ * function, just as the chronological research engine does.
+ */
+export declare function applyWave9AdmissionBatch(inputState: Wave9AdmissionState, rawCandidates: readonly Wave9AdmissionCandidate[], policy?: Readonly<Wave9AdmissionPolicy>): Wave9AdmissionBatchResult;