@reefclaw/openclaw-plugin 0.1.5 → 0.1.7

package/index.js

@@ -12,6 +12,7 @@ import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { BinancePublicApi } from './ccxt/binance-public.js';
 import { IntelPublicApi } from './ccxt/intel-public.js';
+import { resolveMarketDataSource } from './ccxt/public-market-data-api.js';
 import { BinancePrivateApi } from './ccxt/binance-private.js';
 import { ExchangeSimulator } from './simulator/exchange-simulator.js';
 import { ShadowTracker } from './shadow/shadow-tracker.js';
@@ -19,9 +20,10 @@ import { StateManager } from './persistence/state-manager.js';
 import { logger, setLogLevel, formatError } from './logger.js';
 import { DEFAULT_CONFIG } from './types.js';
 import { PaperAdapter } from './paper-adapter.js';
+import { LiveAdapter, } from './live/live-adapter.js';
 import { createLiveAdapter, fillExchangeId, isLiveVenueSupported, parseVenue, venueQuoteCurrency, } from './venues/registry.js';
 import { HyperliquidPublicApi } from './venues/hyperliquid/hl-public.js';
-import { loadBracketMode } from './config/brackets-config.js';
+import { bracketsEnabled, loadBracketMode } from './config/brackets-config.js';
 import { loadUserDataStreamMode, loadUserDataStreamTunables, loadUserDataStreamDbWrite, getUserDataStreamIngestBaseUrl, resolveIngestToken, resolveReefclawUserId, } from './config/user-data-stream-config.js';
 import { TradeStoreClient } from './ingest/trade-store-client.js';
 import { ProposalManager } from './live/proposal-manager.js';
@@ -30,7 +32,9 @@ import { PositionDecisionsClient } from './ingest/position-decisions-client.js';
 import { PositionStateStore } from './live/position-state-store.js';
 import { PendingEntryStore } from './ingest/pending-entry-metadata.js';
 import { onReconcilerObservedClose, reconcileStateStoreOnStartup } from './ingest/reconciler-cleanup.js';
-import { reconcileDbOpenVsExchange } from './ingest/reconcile-db-vs-exchange.js';
+import { reconcileDbOpenVsExchange, startPeriodicDbReconcile } from './ingest/reconcile-db-vs-exchange.js';
+import { onStopWatcherClose } from './ingest/position-auto-capture.js';
+import { ReentryTracker } from './portfolio/reentry-tracker.js';
 import { startReadinessReporter } from './ingest/readiness-reporter.js';
 import { IntelMicrostructureAssembler } from './live/microstructure-assembler.js';
 import { recordPositionReviewsTool } from './tools/record-position-reviews.js';
@@ -42,7 +46,8 @@ import { proposeLearningTool } from './tools/propose-learning.js';
 import { queryReviewOutcomesTool } from './tools/query-review-outcomes.js';
 import { loadPositionReviewMode } from './config/position-review-config.js';
 import { installSignalHandlers } from './lifecycle/install-signal-handlers.js';
-import { readPluginConfig, readOpenClawConnection } from './config/plugin-config-io.js';
+import { SerialTradingOperationLock } from './lifecycle/trading-operation-lock.js';
+import { readPluginConfig, readOpenClawConnection, loadStopWatcherIntervalMs } from './config/plugin-config-io.js';
 import { startConnectorSupervisor, hasBundledBridge } from './connector-supervisor.js';
 import { ToolGate } from './config/tool-gate.js';
 import { gateStore } from './config/gate-store.js';
@@ -94,7 +99,7 @@ import { getRiskScenarioTool } from './tools/get-risk-scenario.js';
 import { getSessionReviewTool } from './tools/get-session-review.js';
 import { getBacktestTool } from './tools/get-backtest.js';
 import { saveStrategyTool } from './tools/save-strategy.js';
-import { listStrategiesTool } from './tools/list-strategies.js';
+import { listStrategiesTool, prepareListStrategiesArgs } from './tools/list-strategies.js';
 import { toggleStrategyTool } from './tools/toggle-strategy.js';
 import { getPatternScanTool } from './tools/get-pattern-scan.js';
 import { scanPairsTool } from './tools/scan-pairs.js';
@@ -110,6 +115,14 @@ import { getDivergencesTool } from './tools/get-divergences.js';
 import { getLiquidationPulseTool } from './tools/get-liquidation-pulse.js';
 import { getRestingLiquidityTool } from './tools/get-resting-liquidity.js';
 import { getFundingContextTool } from './tools/get-funding-context.js';
+import { captureWave9PaperAccountSnapshot, captureWave9PaperPositionFingerprint, Wave9PaperAdmissionGuard, } from './wave9/paper-admission-guard.js';
+import { captureWave9LiveAccount, captureWave9LivePosition, confirmWave9LiveNativeStop, } from './wave9/live-account-capture.js';
+import { Wave9LiveExecutionLedger } from './wave9/live-execution-ledger.js';
+import { recoverWave9LiveExposure } from './wave9/live-autonomous-protection.js';
+import { reconcileWave9LiveDurableRows, } from './wave9/live-startup-reconciliation.js';
+import { Wave9LiveDurableReconciliationScheduler } from './wave9/live-durable-reconciliation-scheduler.js';
+import { inspectWave9LiveSymbolOwnership, } from './wave9/live-symbol-ownership.js';
+import { getWave9StatusTool, IntelWave9ActivationClient, } from './tools/get-wave9-status.js';
 import { refreshTradingParams } from './trading-params-cache.js';
 const TAG = 'paper-trading';
 const PLUGIN_ID = 'reefclaw-paper-trading';
@@ -157,6 +170,9 @@ const TOOL_PARAMS = {
             amount: { type: 'number', description: 'Quantity in base currency (e.g. BTC amount)' },
             price: { type: 'number', description: 'Limit price (required for limit orders)' },
             stopPrice: { type: 'number', description: 'Protective stop-loss trigger price. REQUIRED in live mode when brackets.requireStopLoss is on (default). Must be below entry for longs, above entry for shorts.' },
+            mission_id: { type: 'string', description: 'Canonical mission ID for attribution. Wave 9 requires the exact mission ID returned by get_wave9_status.' },
+            candidate_id: { type: 'string', description: 'Wave 9 only: exact candidate ID returned by get_wave9_status. Invalid on generic orders.' },
+            wave9_admission_token: { type: 'string', description: 'Wave 9 only: short-lived single-use PAPER/LIVE admission token returned by get_wave9_status. Invalid on generic orders.' },
             setup_type: { type: 'string', description: 'Setup classification (e.g. pullback_to_ema, breakout, mean_reversion). REQUIRED in live mode.' },
             thesis: { type: 'string', description: 'Entry reason in 1-2 sentences (≥20 chars). REQUIRED in live mode — the heartbeat reassessment compares against this.' },
             target_price: { type: 'number', description: 'Planned profit target price. REQUIRED in live mode when brackets.requireTakeProfit is on (default).' },
@@ -191,9 +207,11 @@ const TOOL_PARAMS = {
             symbol: { type: 'string', description: 'Symbol of the position to close' },
             reason: {
                 type: 'string',
-                enum: ['regime_flip', 'risk_limit', 'bracket_integrity', 'operator_command'],
-                description: 'Why you are closing manually instead of letting brackets handle it. Must match the decision-matrix trigger in your thinking.',
+                enum: ['regime_flip', 'risk_limit', 'bracket_integrity', 'operator_command', 'wave9_signal_reversal'],
+                description: 'Why you are closing manually instead of letting brackets handle it. wave9_signal_reversal is reserved for an exact get_wave9_status exit authorization.',
             },
+            candidate_id: { type: 'string', description: 'Wave 9 only: exact held candidate ID returned by get_wave9_status.' },
+            wave9_exit_token: { type: 'string', description: 'Wave 9 only: short-lived single-use PAPER/LIVE signal-reversal exit token returned by get_wave9_status.' },
             assessment: {
                 type: 'object',
                 description: 'Structured reasoning — populated from a fresh scorecard run this heartbeat. Required for all reasons except operator_command. Reason-specific consistency is enforced server-side.',
@@ -505,6 +523,11 @@ const TOOL_PARAMS = {
         },
         required: ['symbol'],
     },
+    get_wave9_status: {
+        type: 'object',
+        properties: {},
+        additionalProperties: false,
+    },
     get_analytics: {
         type: 'object',
         properties: {
@@ -651,8 +674,10 @@ const TOOL_PARAMS = {
     list_strategies: {
         type: 'object',
         properties: {
-            active_only: { type: 'boolean', description: 'If true, only return active strategies (default: false — returns all)' },
+            active_only: { type: 'boolean', description: 'Required. Use true for every question about strategies active, usable, available, or tradeable now; use false only when the operator explicitly asks to include inactive strategies.' },
         },
+        required: ['active_only'],
+        additionalProperties: false,
     },
     toggle_strategy: {
         type: 'object',
@@ -926,6 +951,7 @@ const paperTradingPlugin = {
         let apiBaseUrl = 'https://www.reefclaw.com';
         let intelligenceUrl = 'https://intel.reefclaw.com';
         let exchangeConfig = null;
+        let hlCredentials = null;
         let tradingMode = 'PAPER';
         // Trading venue (multi-venue Phase 0 — docs/HYPERLIQUID_INTEGRATION_PLAN.md).
         // Absent config field = 'binance', so every pre-venue install is untouched.
@@ -969,6 +995,18 @@ const paperTradingPlugin = {
                         testnet: exchange.testnet ?? false,
                     };
                 }
+                // Hyperliquid credentials (Phase 3): a MASTER address (queries; holds the
+                // funds) + an AGENT wallet private key (signs; holds nothing, cannot
+                // withdraw or transfer — verified live 2026-07-12). Both are required:
+                // an agent key alone cannot be queried against, and an address alone
+                // cannot sign.
+                if (venue === 'hyperliquid' && exchange?.walletAddress && exchange?.agentPrivateKey) {
+                    hlCredentials = {
+                        walletAddress: String(exchange.walletAddress),
+                        agentPrivateKey: String(exchange.agentPrivateKey),
+                        testnet: exchange.testnet === true,
+                    };
+                }
                 // Read trading mode (default: PAPER)
                 const mode = rcConfig?.tradingMode?.toUpperCase();
                 if (mode === 'SHADOW' || mode === 'MICRO_LIVE' || mode === 'LIVE') {
@@ -1004,10 +1042,18 @@ const paperTradingPlugin = {
             logger.warn(TAG, `Trading mode ${tradingMode} on venue '${venue}' is not supported in this build — falling back to PAPER (live support arrives in Phase 3 of docs/HYPERLIQUID_INTEGRATION_PLAN.md)`);
             tradingMode = 'PAPER';
         }
-        // Validate trading mode vs credentials
-        if (tradingMode !== 'PAPER' && !exchangeConfig) {
-            logger.warn(TAG, `Trading mode ${tradingMode} requires exchange API keys — falling back to PAPER`);
-            tradingMode = 'PAPER';
+        // Validate trading mode vs credentials — PER VENUE (the credential SHAPES
+        // differ: Binance = apiKey/secret, Hyperliquid = master address + agent key).
+        if (tradingMode !== 'PAPER') {
+            if (venue === 'binance' && !exchangeConfig) {
+                logger.warn(TAG, `Trading mode ${tradingMode} requires exchange API keys — falling back to PAPER`);
+                tradingMode = 'PAPER';
+            }
+            else if (venue === 'hyperliquid' && !hlCredentials) {
+                logger.warn(TAG, `Trading mode ${tradingMode} on Hyperliquid requires exchange.walletAddress (master) + ` +
+                    'exchange.agentPrivateKey (agent wallet) — falling back to PAPER');
+                tradingMode = 'PAPER';
+            }
         }
         // Create a BinancePrivateApi for SHADOW mode balance reads whenever
         // credentials exist — even if we start in PAPER, the user can switch
@@ -1092,6 +1138,9 @@ const paperTradingPlugin = {
         // position doesn't leak as status='open' forever (close-bypass class). On by
         // default; env kill-switch RC_JOURNAL_CLOSE_ON_FILL=off disables it.
         const closeOnReduceOnlyFill = process.env.RC_JOURNAL_CLOSE_ON_FILL !== 'off';
+        // Re-entry tracker (issue #204): every close path records the exit so
+        // scan_pairs can flag setups already traded within the current signal bar.
+        const reentryTracker = new ReentryTracker();
         const autoCapture = {
             decisionsClient: positionDecisionsClient,
             stateStore: positionStateStore,
@@ -1103,6 +1152,10 @@ const paperTradingPlugin = {
             // closure — only invoked on a fill, long after `runtime` is built), so it
             // follows a live<->paper reconnect.
             resolveMode: () => (runtime.adapter.isLive ? 'live' : 'paper'),
+            // Active adapter at capture time (deferred closure, same as resolveMode).
+            // Drives the stale-state defense in onCreateOrderFilled (issue #199).
+            resolveAdapter: () => runtime.adapter,
+            reentryTracker,
             // Venue tag (positions.exchange, migration 0058) — static per process;
             // a venue change requires config edit + restart.
             venue,
@@ -1119,6 +1172,7 @@ const paperTradingPlugin = {
         // Read by the create_order tool below to dual-write proposals. See §12 of
         // docs/APPROVAL_MODE_DESIGN.md.
         let proposalManagerCtx;
+        let proposalListenerCredentials;
         // Approval mode read at init from env + plugin-config.json; passed to the
         // create_order tool so it picks the right branch (off / shadow / per_trade).
         let approvalModeForTool = 'off';
@@ -1245,6 +1299,7 @@ const paperTradingPlugin = {
                         manager: new ProposalManager({ baseUrl: ingestBaseUrl, ingestToken }),
                         userId: reefclawUserId,
                     };
+                    proposalListenerCredentials = { ingestToken, userId: reefclawUserId };
                     logger.info(TAG, `Approval wiring active (mode=${approvalModeForTool}) → ${ingestBaseUrl} (userId=${reefclawUserId.slice(0, 8)}…)`);
                 }
                 else if (approvalModeForTool !== 'off') {
@@ -1256,40 +1311,30 @@ const paperTradingPlugin = {
                 // args, identical behavior; the unsupported-venue arm is unreachable
                 // here because the isLiveVenueSupported() gate above already fell back
                 // to PAPER. Phase 3 adds the hyperliquid adapter inside the factory.
-                const liveAdapter = createLiveAdapter(venue, exchangeConfig, tradingMode, microLiveConfig, bracketMode, userDataStreamMode, userDataStreamTunables, tradeIngest, autoCapture);
-                adapter = liveAdapter;
-                // ---- Approval-mode Phase B — start ProposalDecisionListener ----
-                // Started only when approval.mode='per_trade' AND proposalManagerCtx
-                // is wired (creds present). The listener polls /pending-decisions and
-                // fires approved proposals via createOrderTool with proposalManager
-                // omitted — that path runs the real adapter.createOrder.
-                if (approvalModeForTool === 'per_trade' && proposalManagerCtx) {
-                    try {
-                        const approvalCfg = readPluginConfig().approval;
-                        let cfgForUrl;
-                        try {
-                            cfgForUrl = readPluginConfig();
-                        }
-                        catch {
-                            cfgForUrl = undefined;
-                        }
-                        const ingestBaseUrl = getUserDataStreamIngestBaseUrl(cfgForUrl);
-                        proposalDecisionListener = new ProposalDecisionListener({
-                            baseUrl: ingestBaseUrl,
-                            ingestToken: ingestToken,
-                            userId: reefclawUserId,
-                            adapter: liveAdapter,
-                            binanceApi,
-                            autoCapture,
-                            pollIntervalMs: approvalCfg?.pollIntervalMs ?? 3_000,
-                        });
-                        proposalDecisionListener.start();
-                        logger.info(TAG, `ProposalDecisionListener started (poll ${approvalCfg?.pollIntervalMs ?? 3_000} ms)`);
-                    }
-                    catch (err) {
-                        logger.warn(TAG, `Failed to start ProposalDecisionListener: ${String(err)}`);
+                const liveAdapter = createLiveAdapter(venue === 'hyperliquid'
+                    ? {
+                        venue: 'hyperliquid',
+                        args: {
+                            // Non-null by the per-venue credential gate above.
+                            credentials: hlCredentials,
+                            mode: tradingMode,
+                            marketSlippagePct: readPluginConfig().hl?.marketSlippagePct,
+                        },
                     }
-                }
+                    : {
+                        venue: 'binance',
+                        args: [
+                            exchangeConfig,
+                            tradingMode,
+                            microLiveConfig,
+                            bracketMode,
+                            userDataStreamMode,
+                            userDataStreamTunables,
+                            tradeIngest,
+                            autoCapture,
+                        ],
+                    });
+                adapter = liveAdapter;
                 // Reconciler-driven close-bypass cleanup. The reconciler emits
                 // 'drift_detected' on every poll; we filter for 'closed' drifts
                 // (position observed flat on exchange while local thinks it's open).
@@ -1356,7 +1401,17 @@ const paperTradingPlugin = {
                             // are status='open' but absent from the exchange (closed on-exchange
                             // while down / state-store wiped). Same trusted-snapshot-only rule —
                             // a null fetch must never be read as "flat" and close the book.
-                            await reconcileDbOpenVsExchange({ decisionsClient: positionDecisionsClient, userId: positionDecisionsUserId }, trusted.map((p) => p.symbol));
+                            await reconcileDbOpenVsExchange({
+                                decisionsClient: positionDecisionsClient,
+                                userId: positionDecisionsUserId,
+                                // This boot pass only runs in the live-adapter init path and
+                                // diffs against the LIVE snapshot — scope the DB read to the
+                                // live book so open paper rows aren't misread as orphans.
+                                resolveMode: () => 'live',
+                                // …and to the ACTIVE venue (issue #209 item 5): the other
+                                // venue's open rows can never appear in this snapshot.
+                                resolveExchange: () => venue,
+                            }, trusted.map((p) => p.symbol));
                         }
                         else {
                             logger.warn(TAG, 'Startup reconciliation skipped — positions fetch untrusted (null); state-store left untouched. Runtime drift_detected + periodic reconcilers cover the gap.');
@@ -1373,27 +1428,30 @@ const paperTradingPlugin = {
         else {
             adapter = new PaperAdapter(simulator);
         }
-        // PAPER market-data source selection.
+        // Public market-data source selection.
         //
         // Venue precedence (Hyperliquid Phase 1 — docs/HYPERLIQUID_INTEGRATION_PLAN.md):
-        // the configured VENUE decides which exchange prices paper mode, full stop.
-        // venue='hyperliquid' → every public read (PaperMarketFeed marks, the
-        // simulator's fill prices, fetch_ticker/fetch_ohlcv/get_orderbook tools)
-        // comes from Hyperliquid's keyless /info endpoints; the Binance-only
+        // the configured VENUE decides which exchange serves public reads, full
+        // stop, in BOTH books. venue='hyperliquid' → every public read
+        // (PaperMarketFeed marks, the simulator's fill prices,
+        // fetch_ticker/fetch_ohlcv/get_orderbook tools — paper AND live) comes
+        // from Hyperliquid's keyless /info endpoints; the Binance-only
         // `paperMarketDataSource:'intel'` escape hatch does not apply (intel has
         // no HL rows until Phase 2 — silently serving Binance prices for a
         // Hyperliquid book would be a lie, the exact class the symbol-translation
-        // rule forbids).
+        // rule forbids). Pre-fix this was gated on !adapter.isLive, so a LIVE
+        // boot on venue=hyperliquid fell through to Binance for all six
+        // market-data tools while executing on HL.
         //
         // Binance venue (default) is unchanged: a host Binance geo-blocks (HTTP
-        // 451) can route PRICE reads through the intel service by setting
+        // 451) can route PAPER price reads through the intel service by setting
         // plugin-config `paperMarketDataSource:'intel'` (GET /api/price/:symbol).
-        // LIVE always uses the real exchange, and the readiness reporter probes
-        // the CONFIGURED venue. Kill-switch RC_PAPER_MARKET_DATA=binance forces
-        // the Binance-direct default (binance venue only).
+        // The readiness reporter probes the CONFIGURED venue. Kill-switch
+        // RC_PAPER_MARKET_DATA=binance forces the Binance-direct default
+        // (binance venue only).
         //
         // hlPublicApi is constructed once per process when the venue is
-        // hyperliquid — shared by the paper data path and the readiness probe.
+        // hyperliquid — shared by the market-data path and the readiness probe.
         const hlPublicApi = venue === 'hyperliquid' ? new HyperliquidPublicApi({ testnet: venueTestnet }) : null;
         let configuredPaperSource;
         try {
@@ -1405,20 +1463,24 @@ const paperTradingPlugin = {
         const paperDataSource = process.env.RC_PAPER_MARKET_DATA === 'binance'
             ? 'binance'
             : configuredPaperSource ?? 'binance';
-        const useIntelPaperData = venue === 'binance' &&
-            !adapter.isLive && paperDataSource === 'intel' && connectionToken.length > 0;
-        const marketDataApi = !adapter.isLive && hlPublicApi
+        const marketDataSource = resolveMarketDataSource({
+            venue,
+            isLive: adapter.isLive,
+            paperDataSource,
+            hasConnectionToken: connectionToken.length > 0,
+        });
+        const marketDataApi = marketDataSource === 'hyperliquid' && hlPublicApi
             ? hlPublicApi
-            : useIntelPaperData
+            : marketDataSource === 'intel'
                 ? new IntelPublicApi({ connectionToken, intelligenceUrl })
                 : binanceApi;
-        if (!adapter.isLive && hlPublicApi) {
-            logger.info(TAG, `PAPER market data sourced from Hyperliquid${venueTestnet ? ' TESTNET' : ''} (venue=hyperliquid) — use USDC pairs (e.g. BTC/USDC)`);
+        if (marketDataSource === 'hyperliquid') {
+            logger.info(TAG, `${adapter.isLive ? 'LIVE' : 'PAPER'} market data sourced from Hyperliquid${venueTestnet ? ' TESTNET' : ''} (venue=hyperliquid) — use USDC pairs (e.g. BTC/USDC)`);
             if (paperDataSource === 'intel') {
                 logger.warn(TAG, 'paperMarketDataSource=intel is a Binance-venue option — ignored on venue=hyperliquid (intel has no Hyperliquid rows until Phase 2)');
             }
         }
-        else if (useIntelPaperData) {
+        else if (marketDataSource === 'intel') {
             logger.warn(TAG, 'PAPER market data routed through intel (paperMarketDataSource=intel) — prices from GET /api/price; live + readiness still use Binance directly');
         }
         else if (venue === 'binance' && !adapter.isLive && paperDataSource === 'intel' && connectionToken.length === 0) {
@@ -1444,19 +1506,14 @@ const paperTradingPlugin = {
         // see stop-watcher.ts. Operators can override / revert with zero deploy
         // via plugin-config.json `stopWatcher.intervalMs`. Best-effort read;
         // any failure falls back to the (already-reduced) default.
-        let stopWatcherIntervalMs;
-        try {
-            const swMs = readPluginConfig().stopWatcher?.intervalMs;
-            if (typeof swMs === 'number' && Number.isFinite(swMs) && swMs > 0) {
-                stopWatcherIntervalMs = swMs;
-                logger.info(TAG, `Stop-watcher interval overridden via plugin-config: ${swMs}ms`);
-            }
+        const stopWatcherIntervalMs = loadStopWatcherIntervalMs();
+        if (stopWatcherIntervalMs !== undefined) {
+            logger.info(TAG, `Stop-watcher interval overridden via plugin-config: ${stopWatcherIntervalMs}ms`);
         }
-        catch { /* best-effort — default applies */ }
+        const wave9OperationLock = new SerialTradingOperationLock();
         const bootstrapWatcher = stopWatcherIntervalMs !== undefined
-            ? new PositionWatcher(adapter, stopWatcherIntervalMs)
-            : new PositionWatcher(adapter);
-        bootstrapWatcher.start();
+            ? new PositionWatcher(adapter, stopWatcherIntervalMs, wave9OperationLock)
+            : new PositionWatcher(adapter, undefined, wave9OperationLock);
         // Paper-mode background market-data feed. Refreshes the simulator's marks
         // for every symbol with an open position/order (not just the dashboard
         // symbol), so the stop-watcher sees a fresh mark, NAV/uPnL stay live, and
@@ -1467,15 +1524,471 @@ const paperTradingPlugin = {
         if (!adapter.isLive) {
             marketFeed.start();
         }
+        // Journal capture for stop-watcher auto-closes (issue #199). Wired onto
+        // EVERY watcher — the bootstrap one here, reconnect-created ones via the
+        // runtime's onWatcherCreated hook — so a watcher close always journals its
+        // close and drops the state-store mapping (no more phantom positions).
+        const wireWatcherJournalCapture = (watcher) => {
+            watcher.on('stop_closed', (ev) => {
+                onStopWatcherClose(autoCapture, {
+                    symbol: ev.symbol,
+                    stopPrice: ev.stopPrice,
+                    markPrice: ev.markPrice,
+                    order: ev.order,
+                }).catch((err) => {
+                    logger.warn(TAG, `stop-watcher close capture failed: ${formatError(err)}`);
+                });
+            });
+        };
+        wireWatcherJournalCapture(bootstrapWatcher);
         const runtime = new PluginRuntime({
             adapter,
             mode: tradingMode,
             simulator,
             stopWatcher: bootstrapWatcher,
             marketFeed,
+            operationLock: wave9OperationLock,
+            onWatcherCreated: wireWatcherJournalCapture,
         });
+        // Periodic DB-vs-exchange sweep (issues #199/#203): the boot-only reconcile
+        // left phantom-open journal rows alive for days between restarts. Runs for
+        // BOTH books (the paper book previously had NO reconcile at all); trusted-
+        // snapshot discipline preserved (null → skip). First pass shortly after
+        // boot so restart-deploys heal existing phantoms immediately.
+        const dbReconcileSweep = startPeriodicDbReconcile({
+            decisionsClient: positionDecisionsClient,
+            userId: positionDecisionsUserId,
+            resolveAdapter: () => runtime.adapter,
+            // Scope each tick's DB read to the ACTIVE book (deferred closure —
+            // follows a set_trading_mode reconnect). Without this, the sweep
+            // misreads the inactive book's open rows as orphans and synthetically
+            // closes them (they can never appear in this adapter's snapshot).
+            resolveMode: () => (runtime.adapter.isLive ? 'live' : 'paper'),
+            // Venue axis (issue #209 item 5): scope to the configured venue so a
+            // two-venue tenant's other-venue rows are never misread as orphans.
+            resolveExchange: () => venue,
+            describeLastExit: (symbol) => {
+                const a = runtime.adapter;
+                if (a instanceof PaperAdapter) {
+                    const canon = symbol.split(':')[0];
+                    const th = a.getSimulator().getState().tradeHistory;
+                    for (let i = th.length - 1; i >= 0; i--) {
+                        if (th[i].symbol.split(':')[0] === canon) {
+                            const t = th[i];
+                            return `paper engine last trade: close ${t.side} ${t.quantity} @ ${t.exitPrice} at ${t.closedAt} (pnl ${t.realizedPnl.toFixed(4)})`;
+                        }
+                    }
+                    return 'paper engine has NO trade record for this symbol';
+                }
+                return undefined;
+            },
+        });
+        if (dbReconcileSweep) {
+            const bootSweep = setTimeout(() => { void dbReconcileSweep.runOnce(); }, 15_000);
+            bootSweep.unref?.();
+        }
         const intelDeps = { connectionToken, apiBaseUrl };
-        const intelApiDeps = { connectionToken, intelligenceUrl };
+        // venue rides the deps so every intel tool maps agent-facing symbols to
+        // the venue's intel namespace (plan §5.3) — absent/'binance' is
+        // byte-identical passthrough.
+        const intelApiDeps = { connectionToken, intelligenceUrl, venue };
+        const wave9AdmissionGuard = new Wave9PaperAdmissionGuard();
+        let wave9LiveLedger;
+        try {
+            wave9LiveLedger = new Wave9LiveExecutionLedger();
+        }
+        catch (error) {
+            // A malformed durable ledger must disable Wave 9 LIVE admission without
+            // taking unrelated trading and risk-reducing tools offline.
+            logger.error(TAG, `Wave 9 live execution ledger unavailable: ${formatError(error)}`);
+        }
+        const checkWave9LiveSymbolOwnership = async (symbol) => {
+            const ledger = wave9LiveLedger;
+            if (!ledger) {
+                return {
+                    status: 'unavailable',
+                    reason: 'durable_wave9_live_execution_ledger_unavailable',
+                };
+            }
+            return inspectWave9LiveSymbolOwnership(runtime.adapter, ledger, symbol);
+        };
+        if (wave9LiveLedger) {
+            const liveLedger = wave9LiveLedger;
+            const canonicalWave9Symbol = (symbol) => symbol.toUpperCase().replace(/[^A-Z0-9]/g, '').replace(/USDTUSDT$/, 'USDT');
+            const resolveSingleOpenOwner = (symbol) => {
+                const canonical = canonicalWave9Symbol(symbol);
+                const matches = liveLedger.getAll().filter((record) => record.state === 'open'
+                    && record.symbol === canonical);
+                if (matches.length > 1) {
+                    throw new Error(`multiple durable OPEN Wave 9 candidates own ${symbol}; refusing ambiguous lifecycle mutation`);
+                }
+                return matches[0];
+            };
+            const logWave9Recovery = (trigger, result) => {
+                if (result.status === 'flat') {
+                    logger.info(TAG, `Wave 9 LIVE ${trigger}: ${result.symbol} is stably flat and candidate ` +
+                        `${result.candidateId} is durably CLOSED (${result.detail})`);
+                }
+                else if (result.status === 'protected') {
+                    logger.warn(TAG, `Wave 9 LIVE ${trigger}: residual ${result.symbol} is protected by the exact ` +
+                        `frozen stop ${result.stopPrice} (${result.detail})`);
+                }
+                else {
+                    logger.error(TAG, `Wave 9 LIVE ${trigger}: ${result.detail}; candidate ${result.candidateId} ` +
+                        'remains durably OPEN');
+                }
+            };
+            const logWave9ReadyReconciliation = (trigger, result) => {
+                for (const row of result.rows) {
+                    const message = `Wave 9 LIVE ${trigger} reconciliation ${row.status} for ${row.symbol}/` +
+                        `${row.candidateId}: ${row.detail}`;
+                    if (row.status === 'protected')
+                        logger.info(TAG, message);
+                    else if (row.status === 'closed')
+                        logger.info(TAG, message);
+                    else
+                        logger.error(TAG, message);
+                }
+            };
+            const wave9DurableReconciliationScheduler = new Wave9LiveDurableReconciliationScheduler({
+                operationLock: wave9OperationLock,
+                isCurrentSource: (source) => runtime.mode === 'LIVE' && runtime.adapter === source,
+                reconcile: (source) => reconcileWave9LiveDurableRows(source, liveLedger),
+                onResult: logWave9ReadyReconciliation,
+                onError: (trigger, error) => {
+                    logger.error(TAG, `Wave 9 LIVE ${trigger} durable reconciliation failed: ${formatError(error)}; ` +
+                        'IMMEDIATE MANUAL INTERVENTION REQUIRED');
+                },
+            });
+            const handleProtectionLoss = (source, event) => wave9OperationLock.withAccountLock(`wave9_protection_loss:${event.symbol}`, async () => {
+                if (runtime.mode !== 'LIVE' || runtime.adapter !== source) {
+                    logger.warn(TAG, `Ignoring stale Wave 9 protection-loss event for ${event.symbol} from a replaced/non-LIVE adapter`);
+                    return;
+                }
+                const owner = resolveSingleOpenOwner(event.symbol);
+                if (!owner)
+                    return; // Generic/non-Wave9 bracket behavior stays unchanged.
+                if (event.entryClientOrderId !== owner.clientOrderId
+                    || event.entrySide !== owner.side) {
+                    throw new Error(`IMMEDIATE MANUAL INTERVENTION REQUIRED: ${event.symbol} protection-loss event ` +
+                        `belongs to entry ${event.entryClientOrderId}/${event.entrySide}, not durable ` +
+                        `Wave 9 owner ${owner.clientOrderId}/${owner.side}; refusing stale/generic mutation`);
+                }
+                const bracketLedger = source.getBracketLedger();
+                const row = bracketLedger?.getBySymbol(event.symbol);
+                if (row && (row.entryCid !== owner.clientOrderId || row.entrySide !== owner.side)) {
+                    throw new Error(`IMMEDIATE MANUAL INTERVENTION REQUIRED: ${event.symbol} has durable Wave 9 owner ` +
+                        `${owner.candidateId}, but its current bracket belongs to a different entry; ` +
+                        'refusing to auto-close or replace potentially generic protection');
+                }
+                if (row && row.bracketId !== event.bracketId) {
+                    logger.info(TAG, `Ignoring stale Wave 9 stop-loss event ${event.bracketId} for ${event.symbol}; ` +
+                        `current bracket is ${row.bracketId}`);
+                    return;
+                }
+                if (row?.slCid && event.stopClientOrderId && row.slCid !== event.stopClientOrderId) {
+                    logger.info(TAG, `Ignoring stale Wave 9 stop CID ${event.stopClientOrderId} for ${event.symbol}`);
+                    return;
+                }
+                let terminalStopProven = event.source !== 'reconciler_missing';
+                if (event.source === 'reconciler_missing' && event.stopClientOrderId) {
+                    const liveness = await source.resolveBracketLegLiveness(event.stopClientOrderId);
+                    if (liveness === 'live' || liveness === 'unknown') {
+                        logger.info(TAG, `Wave 9 reconciler reported ${event.symbol} stop missing, but exact CID ` +
+                            `${event.stopClientOrderId} is ${liveness}; deferring destructive recovery ` +
+                            'until terminal loss is proven');
+                        return;
+                    }
+                    terminalStopProven = liveness === 'terminal';
+                }
+                else if (event.source === 'reconciler_missing' && !event.stopClientOrderId) {
+                    // A stop was required by the row but no exact stop CID was ever
+                    // persisted or observed in the trusted open-order snapshot.
+                    terminalStopProven = true;
+                }
+                if (row && terminalStopProven
+                    && row.state !== 'cancelled'
+                    && row.state !== 'failed'
+                    && row.state !== 'triggered_sl'
+                    && row.state !== 'triggered_tp') {
+                    try {
+                        bracketLedger?.markState(event.symbol, 'cancelled', {
+                            closeReason: 'cancelled_auto',
+                            lastError: event.detail,
+                        });
+                    }
+                    catch (error) {
+                        logger.error(TAG, `Could not durably terminalize lost Wave 9 stop for ${event.symbol}: ${formatError(error)}; ` +
+                            'continuing to exact re-protection/emergency flatten');
+                    }
+                }
+                const result = await recoverWave9LiveExposure(source, liveLedger, owner.candidateId, event.symbol);
+                logWave9Recovery(event.source, result);
+            });
+            runtime.setWave9LiveLifecycleHooks({
+                configureLiveAdapter: (source) => {
+                    source.setWave9ProtectionLossHandler((event) => handleProtectionLoss(source, event));
+                    wave9DurableReconciliationScheduler.attach(source);
+                },
+                configurePositionWatcher: (watcher, source) => {
+                    wave9DurableReconciliationScheduler.stopIfSourceChanged(source);
+                    watcher.setWave9CloseLifecycle({
+                        resolveCandidateId: (position) => {
+                            if (!source.isLive || runtime.mode !== 'LIVE' || runtime.adapter !== source) {
+                                return undefined;
+                            }
+                            const owner = resolveSingleOpenOwner(position.symbol);
+                            if (!owner)
+                                return undefined;
+                            const expectedSide = owner.side === 'buy' ? 'long' : 'short';
+                            if (position.side !== expectedSide) {
+                                throw new Error(`durable Wave 9 owner ${owner.candidateId} is ${expectedSide}, but exchange position is ${position.side}`);
+                            }
+                            if (position.candidateId && position.candidateId !== owner.candidateId) {
+                                throw new Error(`position candidate ${position.candidateId} does not match durable owner ${owner.candidateId}`);
+                            }
+                            if (!position.candidateId) {
+                                if (!(source instanceof LiveAdapter)) {
+                                    throw new Error('candidate-bound native bracket proof is unavailable');
+                                }
+                                const bracket = source.getBracketLedger()?.getBySymbol(position.symbol);
+                                if (!bracket
+                                    || bracket.entryCid !== owner.clientOrderId
+                                    || bracket.entrySide !== owner.side) {
+                                    throw new Error(`native bracket ownership does not match durable Wave 9 owner ${owner.candidateId}`);
+                                }
+                            }
+                            return owner.candidateId;
+                        },
+                        settleAfterClose: async (candidateId, symbol) => {
+                            if (!source.isLive || runtime.mode !== 'LIVE' || runtime.adapter !== source) {
+                                const record = liveLedger.getByCandidateId(candidateId);
+                                return {
+                                    status: 'manual_intervention',
+                                    detail: 'IMMEDIATE MANUAL INTERVENTION REQUIRED: adapter changed during Wave 9 stop close recovery',
+                                    candidateId,
+                                    symbol,
+                                    stopPrice: record?.initialStop ?? Number.NaN,
+                                };
+                            }
+                            const result = await recoverWave9LiveExposure(source, liveLedger, candidateId, symbol);
+                            logWave9Recovery('stop_watcher', result);
+                            return result;
+                        },
+                    });
+                },
+            });
+        }
+        // Start only after the durable Wave 9 close lifecycle has been installed.
+        // If the ledger failed to load, Wave 9 admission is disabled and generic
+        // watcher behavior still starts normally here.
+        bootstrapWatcher.start();
+        // Start the approved-order listener only after runtime, the shared
+        // mutation lock, and durable Wave 9 ownership state are fully resolved.
+        if (runtime.adapter.isLive
+            && approvalModeForTool === 'per_trade'
+            && proposalManagerCtx
+            && proposalListenerCredentials) {
+            try {
+                const approvalCfg = readPluginConfig().approval;
+                let cfgForUrl;
+                try {
+                    cfgForUrl = readPluginConfig();
+                }
+                catch {
+                    cfgForUrl = undefined;
+                }
+                const ingestBaseUrl = getUserDataStreamIngestBaseUrl(cfgForUrl);
+                proposalDecisionListener = new ProposalDecisionListener({
+                    baseUrl: ingestBaseUrl,
+                    ingestToken: proposalListenerCredentials.ingestToken,
+                    userId: proposalListenerCredentials.userId,
+                    adapter: runtime.adapter,
+                    binanceApi,
+                    autoCapture,
+                    operationLock: wave9OperationLock,
+                    checkWave9LiveSymbolOwnership,
+                    pollIntervalMs: approvalCfg?.pollIntervalMs ?? 3_000,
+                });
+                proposalDecisionListener.start();
+                logger.info(TAG, `ProposalDecisionListener started (poll ${approvalCfg?.pollIntervalMs ?? 3_000} ms)`);
+            }
+            catch (err) {
+                logger.warn(TAG, `Failed to start ProposalDecisionListener: ${String(err)}`);
+            }
+        }
+        const wave9ActivationClient = new IntelWave9ActivationClient(intelApiDeps);
+        const getWave9AccountSnapshot = async () => {
+            if (!runtime.adapter.isLive) {
+                reloadState();
+                // Seed the generic daily-drawdown anchor before binding it into a
+                // Wave 9 fingerprint. Normal create_order keeps getSessionStartNav().
+                runtime.adapter.getSimulator().getSessionStartNav();
+                const capture = captureWave9PaperAccountSnapshot(runtime.adapter);
+                const quote = capture.snapshot.wallet.find((row) => row.currency === capture.snapshot.quoteCurrency);
+                const positions = capture.snapshot.positions.map((position) => {
+                    let positionFingerprint;
+                    try {
+                        positionFingerprint = captureWave9PaperPositionFingerprint(runtime.adapter, position.symbol).fingerprint;
+                    }
+                    catch {
+                        // Malformed or duplicate local geometry remains visible but cannot
+                        // receive a mechanical exit authorization.
+                    }
+                    const strategy = position.strategy === 'tsmom_28d_long_flat_reversal_1d'
+                        || position.strategy === 'tsmom_28d_short_flat_reversal_1d'
+                        ? position.strategy
+                        : undefined;
+                    return {
+                        symbol: position.symbol,
+                        side: position.side,
+                        quantity: position.quantity,
+                        entryPrice: position.entryPrice,
+                        markPrice: position.markPrice,
+                        ...(position.stopPrice !== null ? { stopPrice: position.stopPrice } : {}),
+                        ...(position.missionId ? { missionId: position.missionId } : {}),
+                        ...(position.setupType ? { setupType: position.setupType } : {}),
+                        ...(position.candidateId ? { candidateId: position.candidateId } : {}),
+                        ...(strategy ? { strategy } : {}),
+                        ...(position.accruedFundingUsd !== null
+                            ? { accruedFundingUsd: position.accruedFundingUsd }
+                            : {}),
+                        openedAt: position.openedAt,
+                        ...(positionFingerprint ? { positionFingerprint } : {}),
+                    };
+                });
+                return {
+                    tradingMode: runtime.mode,
+                    positionsAvailable: true,
+                    openOrdersAvailable: true,
+                    openOrderCount: capture.snapshot.openOrders.length,
+                    cashEquityAvailable: quote !== undefined && Number.isFinite(quote.total),
+                    ...(quote !== undefined && Number.isFinite(quote.total)
+                        ? { cashEquityUsd: quote.total }
+                        : {}),
+                    positions,
+                    executedCandidateIds: capture.snapshot.closedWave9CandidateIds,
+                    source: 'paper_simulator_wallet_positions_and_orders',
+                    accountFingerprint: capture.fingerprint,
+                    authoritative: false,
+                    runtimeParity: false,
+                    provenance: capture.provenance,
+                    reasons: [
+                        'cross_process_single_owner_lease_absent',
+                        'cross_process_lease_absent_duplicate_concurrent_admission_not_ruled_out',
+                        'market_mark_fingerprint_drift_requires_immediate_status_recall',
+                    ],
+                };
+            }
+            const nativeStopProtectionAvailable = runtime.mode === 'LIVE'
+                && runtime.adapter instanceof LiveAdapter
+                && bracketsEnabled(loadBracketMode())
+                && runtime.adapter.getBracketManager() !== null
+                && runtime.adapter.getBracketLedger() !== null;
+            if (runtime.mode === 'LIVE' && runtime.adapter.isLive && wave9LiveLedger) {
+                try {
+                    const capture = await captureWave9LiveAccount(runtime.adapter, wave9LiveLedger, 'LIVE');
+                    return {
+                        tradingMode: 'LIVE',
+                        positionsAvailable: true,
+                        openOrdersAvailable: true,
+                        openOrderCount: capture.pendingExposureOrderCount,
+                        cashEquityAvailable: true,
+                        cashEquityUsd: capture.cashEquityUsd,
+                        positions: capture.positions,
+                        executedCandidateIds: capture.executedCandidateIds,
+                        source: 'live_exchange_wallet_positions_orders_and_wave9_ledger',
+                        accountFingerprint: capture.fingerprint,
+                        authoritative: capture.authoritative,
+                        runtimeParity: false,
+                        provenance: capture.provenance,
+                        adapterReadiness: runtime.adapter.readiness,
+                        nativeStopProtectionAvailable: nativeStopProtectionAvailable && capture.nativeStopProtectionComplete,
+                        reasons: [
+                            'live_candidate_identity_uses_local_durable_execution_ledger',
+                            'cross_process_lease_absent_duplicate_concurrent_admission_not_ruled_out',
+                            'live_funding_is_not_attributed_per_wave9_position',
+                            ...capture.nativeStopIssues.map((issue) => `native_stop_issue:${issue}`),
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        tradingMode: 'LIVE',
+                        positionsAvailable: false,
+                        openOrdersAvailable: false,
+                        cashEquityAvailable: false,
+                        positions: [],
+                        source: 'live_exchange_snapshot_unavailable',
+                        authoritative: false,
+                        runtimeParity: false,
+                        provenance: 'live_exchange_snapshot_unavailable',
+                        adapterReadiness: runtime.adapter.readiness,
+                        nativeStopProtectionAvailable,
+                        reasons: [`live_snapshot_failed:${formatError(error)}`],
+                    };
+                }
+            }
+            return {
+                tradingMode: runtime.mode,
+                positionsAvailable: false,
+                openOrdersAvailable: false,
+                cashEquityAvailable: false,
+                positions: [],
+                source: 'wave9_execution_runtime_unavailable',
+                authoritative: false,
+                runtimeParity: false,
+                provenance: 'wave9_execution_runtime_unavailable',
+                adapterReadiness: runtime.adapter.readiness,
+                nativeStopProtectionAvailable,
+                reasons: [
+                    wave9LiveLedger
+                        ? 'Wave 9 execution requires the current mode to be PAPER or an exact LIVE exchange runtime'
+                        : 'Wave 9 live execution ledger is unavailable',
+                ],
+            };
+        };
+        const captureWave9AccountFingerprint = async () => {
+            if (runtime.mode !== 'LIVE' || !runtime.adapter.isLive || !wave9LiveLedger) {
+                throw new Error('Wave 9 authoritative LIVE account capture is unavailable');
+            }
+            const capture = await captureWave9LiveAccount(runtime.adapter, wave9LiveLedger, 'LIVE');
+            return { fingerprint: capture.fingerprint };
+        };
+        const captureWave9PositionFingerprint = async (symbol) => {
+            if (runtime.mode !== 'LIVE' || !runtime.adapter.isLive || !wave9LiveLedger) {
+                throw new Error('Wave 9 authoritative LIVE position capture is unavailable');
+            }
+            return captureWave9LivePosition(runtime.adapter, wave9LiveLedger, 'LIVE', symbol);
+        };
+        const confirmWave9LiveStop = async (input) => {
+            if (runtime.mode !== 'LIVE' || !(runtime.adapter instanceof LiveAdapter))
+                return false;
+            const liveAdapter = runtime.adapter;
+            const bracketLedger = liveAdapter.getBracketLedger();
+            if (!bracketLedger || !liveAdapter.getBracketManager())
+                return false;
+            const deadline = Date.now() + 20_000;
+            while (Date.now() < deadline) {
+                if (runtime.mode !== 'LIVE' || runtime.adapter !== liveAdapter)
+                    return false;
+                const bracket = bracketLedger.getBySymbol(input.symbol);
+                if (bracket?.state === 'failed'
+                    || bracket?.state === 'cancelled'
+                    || bracket?.state === 'triggered_sl'
+                    || bracket?.state === 'triggered_tp')
+                    return false;
+                if (bracket && (bracket.entryCid !== input.entryClientOrderId
+                    || bracket.entrySide !== input.entrySide))
+                    return false;
+                if (bracket
+                    && (bracket.state === 'active' || bracket.state === 'partial')) {
+                    return confirmWave9LiveNativeStop(liveAdapter, input);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+            return false;
+        };
         // Facts-out local signal service (step 5). Created ONLY when the operator
         // flips signals.evaluator to shadow/enforce in plugin-config — default
         // 'central' leaves the get_signals path byte-identical (no service, no SSE
@@ -1605,10 +2118,21 @@ const paperTradingPlugin = {
                 parameters: TOOL_PARAMS.create_order,
                 execute: async (_id, params) => jsonResult(await createOrderTool(params, {
                     ...adapterDeps,
+                    adapter: runtime.adapter,
                     autoCapture,
                     proposalManager: proposalManagerCtx?.manager,
                     userId: proposalManagerCtx?.userId,
                     approvalMode: approvalModeForTool,
+                    wave9AdmissionGuard,
+                    wave9ActivationCheck: () => wave9ActivationClient.getActivation(),
+                    refreshPaperState: reloadState,
+                    wave9TradingModeCheck: () => runtime.mode,
+                    wave9VenueCheck: () => venue,
+                    captureWave9AccountFingerprint,
+                    confirmWave9LiveStop,
+                    wave9LiveLedger,
+                    checkWave9LiveSymbolOwnership,
+                    operationLock: wave9OperationLock,
                 })),
             },
             {
@@ -1616,42 +2140,78 @@ const paperTradingPlugin = {
                 label: 'Cancel Order',
                 description: 'Cancel a single open order by its ID.',
                 parameters: TOOL_PARAMS.cancel_order,
-                execute: async (_id, params) => jsonResult(await cancelOrderTool(params, adapterDeps)),
+                execute: async (_id, params) => jsonResult(await cancelOrderTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    operationLock: wave9OperationLock,
+                    checkWave9LiveSymbolOwnership,
+                })),
             },
             {
                 name: 'cancel_all_orders',
                 label: 'Cancel All Orders',
                 description: 'Cancel all open orders, optionally filtered by symbol.',
                 parameters: TOOL_PARAMS.cancel_all_orders,
-                execute: async (_id, params) => jsonResult(await cancelAllOrdersTool(params, adapterDeps)),
+                execute: async (_id, params) => jsonResult(await cancelAllOrdersTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    operationLock: wave9OperationLock,
+                })),
             },
             {
                 name: 'close_position',
                 label: 'Close Position',
                 description: 'Close an open position at market price by creating an opposing market order.',
                 parameters: TOOL_PARAMS.close_position,
-                execute: async (_id, params) => jsonResult(await closePositionTool(params, { ...adapterDeps, autoCapture })),
+                execute: async (_id, params) => jsonResult(await closePositionTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    autoCapture,
+                    wave9AdmissionGuard,
+                    refreshPaperState: reloadState,
+                    wave9TradingModeCheck: () => runtime.mode,
+                    wave9VenueCheck: () => venue,
+                    captureWave9PositionFingerprint,
+                    wave9LiveLedger,
+                    checkWave9LiveSymbolOwnership,
+                    operationLock: wave9OperationLock,
+                })),
             },
             {
                 name: 'modify_stop',
                 label: 'Modify Stop',
                 description: 'Move the exchange-side stop-loss on an open live position. Atomic cancel-then-resubmit with automatic rollback. Live mode only; requires brackets.mode enabled.',
                 parameters: TOOL_PARAMS.modify_stop,
-                execute: async (_id, params) => jsonResult(await modifyStopTool(params, adapterDeps)),
+                execute: async (_id, params) => jsonResult(await modifyStopTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    operationLock: wave9OperationLock,
+                    checkWave9LiveSymbolOwnership,
+                })),
             },
             {
                 name: 'modify_target',
                 label: 'Modify Target',
                 description: 'Move the exchange-side take-profit on an open live position. Atomic cancel-then-resubmit with automatic rollback. Live mode only; requires brackets.mode enabled.',
                 parameters: TOOL_PARAMS.modify_target,
-                execute: async (_id, params) => jsonResult(await modifyTargetTool(params, adapterDeps)),
+                execute: async (_id, params) => jsonResult(await modifyTargetTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    operationLock: wave9OperationLock,
+                    checkWave9LiveSymbolOwnership,
+                })),
             },
             {
                 name: 'attach_brackets',
                 label: 'Attach Brackets',
                 description: 'Bootstrap exchange-side STOP_MARKET + TAKE_PROFIT_MARKET protection on an existing open live position that is currently naked. Use this to recover when a position exists without active brackets (e.g. after kill-switch stripped them or brackets failed to attach at entry). Rejects if brackets are already active for the symbol — use modify_stop / modify_target instead. Live mode only; requires brackets.mode enabled.',
                 parameters: TOOL_PARAMS.attach_brackets,
-                execute: async (_id, params) => jsonResult(await attachBracketsTool(params, adapterDeps)),
+                execute: async (_id, params) => jsonResult(await attachBracketsTool(params, {
+                    ...adapterDeps,
+                    adapter: runtime.adapter,
+                    operationLock: wave9OperationLock,
+                    checkWave9LiveSymbolOwnership,
+                })),
             },
             {
                 name: 'audit_bracket_protection',
@@ -1799,6 +2359,19 @@ const paperTradingPlugin = {
                 parameters: TOOL_PARAMS.get_signals,
                 execute: async (_id, params) => jsonResult(await getSignalsTool(params, getSignalsDeps)),
             },
+            {
+                name: 'get_wave9_status',
+                label: 'Get Wave 9 Status',
+                description: 'MANDATORY fresh call for every question about which strategies are active, usable, available, or tradeable now: never answer from memory; also call list_strategies fresh with active_only=true in the same turn. The operator reply MUST reproduce every line from requiredOperatorReport.lines exactly enough to preserve all labels, counts, and reasons. These are read-only status calls; the question alone does not authorize placing or closing an order or toggling a strategy. Return any single-use entry or reversal token. An empty token set means wait for the next valid signal/window; it does not disable LIVE trading. LIVE orders use real capital.',
+                parameters: TOOL_PARAMS.get_wave9_status,
+                execute: async () => jsonResult(await getWave9StatusTool({
+                    activationClient: wave9ActivationClient,
+                    getAccountSnapshot: getWave9AccountSnapshot,
+                    operationLock: wave9OperationLock,
+                    authorizationIssuer: wave9AdmissionGuard,
+                    executionVenue: venue,
+                })),
+            },
             {
                 name: 'get_analytics',
                 label: 'Get Edge Analytics',
@@ -1910,9 +2483,10 @@ const paperTradingPlugin = {
             {
                 name: 'list_strategies',
                 label: 'List Strategies',
-                description: 'List all strategies in the Strategy Box. Shows name, description, regime whitelist, conditions, active status, and whether it is a built-in strategy. Use to see which strategies are available for backtesting and live trading.',
+                description: 'MANDATORY for every question about which strategies are active, usable, available, or tradeable now: never answer from memory; call this tool fresh with active_only=true and also call get_wave9_status fresh in the same turn. The operator reply MUST reproduce every line from get_wave9_status.requiredOperatorReport.lines exactly enough to preserve all labels, counts, and reasons. List strategies in the Strategy Box with name, description, regime whitelist, conditions, active status, and whether each is built in. Active means the operator enabled the strategy; it does not mean an order is authorized this instant. These are read-only status calls; the question alone does not authorize placing or closing an order or toggling a strategy.',
                 parameters: TOOL_PARAMS.list_strategies,
-                execute: async (_id, params) => jsonResult(await listStrategiesTool(params ?? {}, intelApiDeps)),
+                prepareArguments: prepareListStrategiesArgs,
+                execute: async (_id, params) => jsonResult(await listStrategiesTool(prepareListStrategiesArgs(params), intelApiDeps)),
             },
             {
                 name: 'toggle_strategy',
@@ -1929,6 +2503,7 @@ const paperTradingPlugin = {
                 execute: async (_id, params) => jsonResult(await scanPairsTool(params ?? {}, intelApiDeps, {
                     decisionsClient: positionDecisionsClient,
                     userId: positionDecisionsUserId,
+                    reentryTracker,
                 })),
             },
             {